Java编程之Map中分拣思想。

 1 /**
 2  * 作为包装类，用来存放英文单词，和该英文单词出现的次数
 3 * @ClassName: Str 
 4 * @Description: TODO(这里用一句话描述这个类的作用) 
 5 * @author 尚晓飞
 6 * @date 2014-7-30 下午6:57:29 
 7 *
 8  */
 9 public class Str {
10     private String st;
11     private int count;
12     public Str() {
13         super();
14     }
15     public String getSt() {
16         return st;
17     }
18     public void setSt(String st) {
19         this.st = st;
20     }
21     public int getCount() {
22         return count;
23     }
24     public void setCount(int count) {
25         this.count = count;
26     }
27 
28     
29 }

 1 /**
 2  * 字符串：this is a cat and that is a nice and where is the food
 3  * 将该字符串的每个单词出现的次数统计出来
 4  * 【分拣的思想】
 5  *  第一种：为所有key创建容器
 6  *        之后存放对应的value
 7  *  第二种:第一次创建容器，并存放value
 8  *       第二次之后，直接使用容器存放value
 9 * @ClassName: TestMap 
10 * @Description: TODO(这里用一句话描述这个类的作用) 
11 * @author 尚晓飞
12 * @date 2014-7-30 下午6:58:16 
13 *
14  */
15 public class TestMap {
16     
17     public static void main(String[] args) {
18         test4();
19         
20     }
21     
22     //第一种分拣思路 （1）先为所有的key创建对应的容器（2）为对应key的容器中存放值
23     public static void test1(){
24         String sts="this is a cat and that is a nice and where is the food";
25         //将字符串分割成一个个单词，并存放入数组中
26         String[] strings=sts.split(" ");
27         //创建一个map对象，用来存放单词和单词出现的次数
28         Map<String, Str> countMap=new HashMap<String, Str>();
29         //第一种分拣思想
30         //第一步：为所有的key创建容器，
31         for(int i=0;i<strings.length;i++){
32             String temp=strings[i];
33             //判断map是否含有此key，如果有返回true,否则返回false
34             //第一次为所有的key创建容器
35             if(!countMap.containsKey(temp)){
36                 Str str=new Str();
37                 countMap.put(temp, str);
38             }
39         }
40         
41         //第二步:使用容器，存放值
42         for(String temp:strings){
43             Str clsStr=countMap.get(temp);
44             clsStr.setCount(clsStr.getCount()+1);
45             clsStr.setSt(temp);
46         }
47         
48         
49         //测试countMap是否算是成功达到目的
50         Set<String> keys=countMap.keySet();
51         for (String key:keys) {
52             Str sd=countMap.get(key);
53             Integer cInteger=sd.getCount();
54             System.out.println("字母："+key+"--次数:"+cInteger);
55         }
56         
57     }
58     //第一种分拣思路 （1）先为所有的key创建对应的容器（2）为对应key的容器中存放值
59     public static void test2(){
60         String sts="this is a cat and that is a nice and where is the food";
61         //将字符串分割成一个个单词，并存放入数组中
62         String[] strings=sts.split(" ");
63         //创建一个map对象，用来存放单词和单词出现的次数
64         Map<String, Str> countMap=new HashMap<String, Str>();
65         //第一种分拣思想
66         //第一步：为key创建容器的同时，并存放值
67         for(int i=0;i<strings.length;i++){
68             String temp=strings[i];
69             //判断map是否含有此key，如果有返回true,否则返回false
70             //先创建容器，之后为容器存放值
71             if(!countMap.containsKey(temp)){
72                 Str str=new Str();
73                 countMap.put(temp, str);
74             }
75                 //使用容器存放值
76                 Str str=countMap.get(temp);
77                 str.setCount(str.getCount()+1);
78             
79         }
80         
81         //测试countMap是否算是成功达到目的
82                 Set<String> keys=countMap.keySet();
83                 for (String key:keys) {
84                     Str sd=countMap.get(key);
85                     Integer cInteger=sd.getCount();
86                     System.out.println("字母："+key+"--次数:"+cInteger);
87                 }
88     }
89 
90 }

 1  * 【分拣的思想】
 2  *  第一种：为所有key创建容器
 3  *        之后存放对应的value
 4  *  第二种:第一次创建容器，并存放value
 5  *       第二次之后，直接使用容器存放value
 6 * @ClassName: TestMap 
 7 * @Description: TODO(这里用一句话描述这个类的作用) 
 8 * @author 尚晓飞
 9 * @date 2014-7-30 下午6:58:16 
10 *
11  */
12 public class TestMap {
13     
14     public static void main(String[] args) {
15         test4();
16         
17     }
18     
19     
20     
21     //分拣第二种思想 （1）第一次为key创建容器，并存放值（2）第二次使用容器存放值
22     public static void test3(){
23         String sts="this is a cat and that is a nice and where is the food";
24         //将字符串分割成一个个单词，并存放入数组中
25         String[] strings=sts.split(" ");
26         //创建一个map对象，用来存放单词和单词出现的次数
27         Map<String, Str> countMap=new HashMap<String, Str>();
28         //第一种分拣思想
29         //第一步：为key创建容器的同时，并存放值
30         for(int i=0;i<strings.length;i++){
31             String temp=strings[i];
32             //判断map是否含有此key，如果有返回true,否则返回false
33             //第一次创建容器，并为容器中存放值
34             if(!countMap.containsKey(temp)){
35                 Str str=new Str();
36                 str.setCount(1);
37                 countMap.put(temp, str);
38             }else{
39                 //第二次使用容器存放值
40                 Str str=countMap.get(temp);
41                 str.setCount(str.getCount()+1);
42             }
43         }
44         
45         //测试countMap是否算是成功达到目的
46                 Set<String> keys=countMap.keySet();
47                 for (String key:keys) {
48                     Str sd=countMap.get(key);
49                     Integer cInteger=sd.getCount();
50                     System.out.println("字母："+key+"--次数:"+cInteger);
51                 }
52     }
53     
54     
55     //第二种分拣思路：（1）第一次为key创建容器，并存放值（2）第二次使用容器存放值
56     public static void test4(){
57         String sts="this is a cat and that is a nice and where is the food";
58         //将字符串分割成一个个单词，并存放入数组中
59         String[] strings=sts.split(" ");
60         //创建一个map对象，用来存放单词和单词出现的次数
61         Map<String, Str> countMap=new HashMap<String, Str>();
62         //第一种分拣思想
63         //第一步：为key创建容器的同时，并存放值
64         for(int i=0;i<strings.length;i++){
65             String temp=strings[i];
66             //判断map是否含有此key，如果有返回true,否则返回false
67             //第一次创建容器，并为容器中存放值
68             Str str=null;
69             if(null==(str=countMap.get(temp))){
70                  str=new Str();
71                 str.setCount(1);
72                 countMap.put(temp, str);
73             }else{
74                 //第二次使用容器存放值
75                  str=countMap.get(temp);
76                 str.setCount(str.getCount()+1);
77             }
78         }
79         
80         //测试countMap是否算是成功达到目的
81                 Set<String> keys=countMap.keySet();
82                 for (String key:keys) {
83                     Str sd=countMap.get(key);
84                     Integer cInteger=sd.getCount();
85                     System.out.println("字母："+key+"--次数:"+cInteger);
86                 }
87     }
88 }