Java编程之Map中分拣思想。

题目:给定一个字符串,求出字符串中每一个单词在字符串中出现的次数

旨意:map的分拣思想。

每一个key的包装类,存放出现的次数

 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)先为key创建对应的容器(2)使用容器,存放key对应的值

 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)第一次为key创建容器,并存key对应的值(2)第二次使用创建好的容器,存放key对应的值

 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 }

Java编程之Map中分拣思想。,布布扣,bubuko.com

时间: 07-29

Java编程之Map中分拣思想。的相关文章

java 线程之concurrent中的常用工具 CyclicBarrier

一.CyclicBarrier CyclicBarrier是一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point).在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用.因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier. CyclicBarrier类似于CountDownLatch也是个计数器, 不同的是CyclicBarrier数的是调用了CyclicBa

黑马程序员——Java网络编程之UDP传输

网络编程 网络模型 通讯要素:InetAddress(对象):ip地址,网络中设备的标识,不可记忆,可用主机名,本地回环地址:127.0.0.1主机名localhost 端口号 传输协议:UDP,将数据的源及目的封装成数据包中,不需要建立连接,每个数据包的大小限制在64K内,无连接,是不可靠协议,不需要建立连接,速度快.力求速度,不求数据的准确性.比如聊天软件,网络会议. TCP:建立连接,形成传输数据的通道,在连接中进行大数据量传输,通过三次握手完成连接,是可靠协议,必须建立连接效率稍低. S

【转】JAVA网络编程之Socket用法

JAVA网络编程之Socket用法 分类: JAVA2012-08-24 15:56 710人阅读 评论(0) 收藏 举报 在客户/服务器通信模式中,客户端需要主动建立与服务器连接的Socket,服务器端收到客户端的连接请求,也会创建与客户端连接的Socket.Socket可以看做是通信连接两端的收发器,客户端和服务店都通过Socket来收发数据. 1.构造Socket public Socket() 通过系统默认类型的 SocketImpl 创建未连接套接字 public Socket(Str

java网络编程之UDP实例

package Socket; import java.net.DatagramPacket; import java.net.InetAddress; public class Dgram { public static DatagramPacket toDatagram(String s, InetAddress destIA, int destPort) { byte[] buf = new byte[s.length() + 1]; s.getBytes(0, s.length(), b

java网络编程之TCP实例

Dgram类 package Socket; import java.net.DatagramPacket; import java.net.InetAddress; public class Dgram { public static DatagramPacket toDatagram(String s, InetAddress destIA, int destPort) { byte[] buf = new byte[s.length() + 1]; s.getBytes(0, s.leng

Java中分拣存储的demo

  //Letter.java package yzhou.map; /** * * @author 洋 * */ public class Letter { private String name; private int count; public Letter() { // TODO Auto-generated constructor stub } public Letter(String name) { super(); this.name = name; } public Lette

Java集合篇六:Map中key值不可重复的测试

package com.test.collection; import java.util.HashMap; import java.util.Map; //Map中key值不可重复的测试 public class TestEquals { public static void main(String[] args) { String s1=new String("abc"); String s2=new String("abc"); Map map=new Has

Java知多少(103)网络编程之IP地址和InetAddress类

Java语言的优势之一是Java程序能访问网络资源.Java提供一系列的类支持Java程序访问网络资源. TCP/IP协议和IP地址 为了进行网络通信,通信双方必须遵守通信协议.目前最广泛使用的是TCP/IP协议,它是Internet中各方所遵循的公共协议.TCP(Transport Control Protocol)是一种传输控制协议,IP(Internet Protocol)是一种网际协议,TCP/IP代表这两个协议的. TCP/IP分为四个层次: 网络接口层:负责接收和发送物理帧: 网络层

一次没有最后期限的编程之旅

今年上半年,是我工作以来最繁忙的六个月,总之遇到了最艰难的教程.最冗长的文档.最繁琐的代码以及最窘迫的合作,最终的极度疲劳成了压垮了我的最后一根稻草. 那年杭州,接连40摄氏度以上的连续高温,忽然一天39度,竟然觉得整个世界都清凉了.人,就是这么犯贱,稍有舒缓,便全然忘记曾经的抓狂. “写一个Apple Watch APP玩玩”,忽然闪过这么一个念头.这对执着于<证明论>和<集合论>的苦行者而言,浮现的不过是一次短暂的旅行. 旅行,不是迁移,抑或流浪,终究是要回归的. 记得还是在2