头歌Educoder——Java 字符串与集合练习—词频统计

ゝ一世哀愁。 2022-11-11 14:44 357阅读 0赞

### 文章目录 ###

*  第1关：单词分割
 *   *  任务描述
     *  相关知识
     *   *  String.split()拆分字符串
         *  StringTokenizer类拆分字符串
     *  编程要求
     *  测试说明
     *  代码示例
     *   *  test.java
         *  StudentDemo.java
 *  第2关：确定单词在字符串中的位置
 *   *  任务描述
     *  相关知识
     *   *  String.indexOf(String str)
         *  String.indexOf(String str, int fromIndex)
     *  编程要求
     *  测试说明
     *  代码示例
     *   *  test.java
         *  StudentDemo.java
 *  第3关：实现词频统计和排序输出
 *   *  任务描述
     *  相关知识
     *   *  统计相同单词的次数
         *  如何进行排序
     *  编程要求
     *  测试说明
     *  代码示例
     *   *  StudentDemo.java
         *  test.java
         *  readme.txt

# 第1关：单词分割 #

## 任务描述 ##

本关任务：将一段英语字符串进行单词分割。

## 相关知识 ##

为了完成本关任务，你需要掌握：如何将字符串进行分割。

### String.split()拆分字符串 ###

`lang`包`String`类的`split()`方法

public String[] split(String regex)
    public String[] split(String regex，int limit)
    //limit 参数控制模式应用的次数，因此影响所得数组的长度

拆分示例:

public class SplitDemo { 
        public static void main(String[] args) { 
            String Str="Harry James Potter";
            String[] StrArray=Str.split("\\s");//"\\s"表示空格
            //也可以来" "来进行拆分 String[] StrArray=Str.split(" ");
            for(String str:StrArray){ 
                System.out.println(str);
            }
    }

运行结果

`Harry`

`James`

`Potter`

### StringTokenizer类拆分字符串 ###

`util`包下的`StringTokenizer`类

*  拆分原理

`StringTokenizer`拆分字符串的原理是通过生成`StringTokenizer`对象，然后运用对象的属性来处理字符串拆分的。

public StringTokenizer(String str,String delim,boolean returnDelims)
    public StringTokenizer(String str,String delim)
    public StringTokenizer(String str)
    //str:要解析的字符串 delim:分隔符 returnDelims:是否将分隔符作为标记返回

拆分示例：

import java.util.StringTokenizer;
    public class StringTokenDemo { 
        public static void main(String[] args) { 
            String Str="Harry James Potter";
            StringTokenizer strToken=new StringTokenizer(Str);
            //当有拆分的子字符串时，输出这个字符串
            while(strToken.hasMoreTokens()){ 
                System.out.println(strToken.nextToken());
            }
        }
    }

运行结果

`Harry`

`James`

`Potter`

## 编程要求 ##

请仔细阅读右侧代码，根据方法内的提示，在`Begin - End`区域内进行代码补充，具体任务如下：

*  用`String.split()`方法将字符串“aaa|bbb|ccc”以“|”进行拆分，用`StringTokenizer`类将字符串`“This?is?a?test?string”以“?”`进行拆分。

## 测试说明 ##

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

测试输入：

`aaa|bbb|ccc`

`This?is?a?test?string`

预期输出：

`aaa`

`bbb`

`ccc`

`This`

`is`

`a`

`test`

`string`

提示: `“|”`、`“.”`、`“*”`、`“+”`、`“\\”`等不是有效的模式匹配规则表达式，是转义字符，使用`split()`方法时必须得加`"\\"`才行。

--------------------

开始你的任务吧，祝你成功！

## 代码示例 ##

### test.java ###

package step1;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Scanner;
    public class test{ 
    	public static void main(String[] args){ 
    		Scanner sc=new Scanner(System.in);
    		StudentDemo demo=new StudentDemo();
    		String str1=sc.nextLine();
    		String str2=sc.nextLine();
    		List<String> list1=demo.splitPartition(str1);
    		List<String> list2=demo.tokenPartition(str2);
    		for(String s:list1){ 
    			System.out.println(s);
    		}
    		System.out.println();
    		for(String s:list2){ 
    			System.out.println(s);
    		}
    		
    	}
    }

### StudentDemo.java ###

package step1;
    
    import java.util.List;
    import java.util.ArrayList;
    import java.util.StringTokenizer;
    
    public class StudentDemo { 
    
    	// 使用String.split()方法分割
    	public List<String> splitPartition(String str) { 
    		List<String> list = new ArrayList<String>();
    
    		//请在此添加实现代码
    		/********** Begin **********/
    
    		String[] strings = str.split("\\|");
    		for (String string : strings) { 
    			list.add(string);
    		}
    		/********** End **********/
    
    		return list;
    	}
    
    	// 使用StringTokenizer类进行分割
    	public List<String> tokenPartition(String str) { 
    		List<String> list = new ArrayList<String>();
    		// 请在此添加实现代码
    		/********** Begin **********/
    
    		StringTokenizer strings = new StringTokenizer(str, "?");
    		while (strings.hasMoreTokens()) { 
    			list.add(strings.nextToken());
    		}
    		/********** End **********/
    
    		return list;
    	}
    
    }

# 第2关：确定单词在字符串中的位置 #

## 任务描述 ##

本关任务：得到一个单词在一段字符串中的位置。

## 相关知识 ##

为了完成本关任务，你需要掌握：如何获取字符串中指定单词出现的下标

### String.indexOf(String str) ###

返回指定子字符串在此字符串中第一次出现处的索引。（若返回-1则表示在该字符串中没有你要找的单词）

//声明一段字符串
    String str="Can I help you";
    //显示“I”在str中第一次出现的下标
    System.out.println(str.indexOf("I"));
    //String.indexOf(int ch)方法与此方法形同，只是参数是单个字符的ASCII码

输出：`4`

### String.indexOf(String str, int fromIndex) ###

返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

String str="Can I help you";
    System.out.println(str.indexOf("I",5));
    //同样String.indexOf(int ch, int fromIndex)方法与此方法也形同，只是参数是单个字符的ASCII码

输出：`-1`

## 编程要求 ##

请仔细阅读右侧代码，根据方法内的提示，在`Begin - End`区域内进行代码补充，具体任务如下：

*  列出给定字符串中每个单词(按`“ ”`，`“,”`，`“?”`，`“.”`，`“!”`，`“:”`，`“\n”`分割)首次出现的位置。

## 测试说明 ##

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

测试输入：

`No arguments will give courage to the coward.`

预期输出：

`单词：the---首次出现的角标34`

`单词：No---首次出现的角标0`

`单词：give---首次出现的角标18`

`单词：will---首次出现的角标13`

`单词：arguments---首次出现的角标3`

`单词：to---首次出现的角标31`

`单词：coward---首次出现的角标38`

`单词：courage---首次出现的角标23`

提示：

//1.分割单词时可一次进行
    //2.可以采用Map集合的键值对存储
    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("Hello",0);
    map.put("world",1);
    Set<Entry<String, Integer>> entrySet = wordCount.entrySet();
    for (Entry<String, Integer> entry : entrySet) { 
            System.out.println(entry.getKey()+"---"+entry.getValue());
    }

输出：

`Hello---0`

`world---1`

--------------------

开始你的任务吧，祝你成功！

## 代码示例 ##

### test.java ###

package step2;
    import java.util.Scanner;
    import java.util.Map;
    import java.util.HashMap;
    import java.util.Set;
    import java.util.Map.Entry;
    public class test{ 
    	public static void main(String[] args){ 
    		StudentDemo demo=new StudentDemo();
    		Scanner sc=new Scanner(System.in);
    		String next=sc.nextLine();
    		Map<String, Integer> map = demo.getMap(next);
    		Set<Entry<String, Integer>> entrySet = map.entrySet();
    		for (Entry<String, Integer> entry : entrySet) { 
    			System.out.println("单词："+entry.getKey()+"---首次出现的角标"+entry.getValue());
    		}
    	}
    }

### StudentDemo.java ###

package step2;
    
    import java.util.Map;
    import java.util.HashMap;
    import java.util.StringTokenizer;
    
    public class StudentDemo { 
    	// 返回一个Map集合来得到单词和首次出现的下标 key为单词名称 value为单词的角标
    	public Map<String, Integer> getMap(String str) { 
    		Map<String, Integer> map = new HashMap<String, Integer>();
    		// 对str进行分割 再加入map集合中
    		// 请在此添加实现代码
    		/********** Begin **********/
    		StringTokenizer stn = new StringTokenizer(str, " ,?.!:\n");
    
    		while (stn.hasMoreTokens()) { 
    			String str1 = stn.nextToken();
    			map.put(str1, str.indexOf(str1));
    		}
    
    		/********** End **********/
    
    		return map;
    	}
    
    }

# 第3关：实现词频统计和排序输出 #

## 任务描述 ##

本关任务：编写一个能计算一段文本内容中出现单词的次数的降序排列的小程序。

## 相关知识 ##

为了完成本关任务，你需要掌握：

1.如何统计相同单词的次数；

2.如何进行排序。

### 统计相同单词的次数 ###

//使用map集合进行存储
    String s="Day by Day";
    Map<String,Integer> map=new HashMap<String,Integer>();
    StringTokenizer tokenizer=new StringTokenizer(s);
    int count;//记录次数
    String word;//单个单词
    while(tokenizer.hasMoreTokens()){ 
        word=tokenizer.nextToken(" ");
        if(map.containsKey(word)){ 
            //拿到之前存在map集合中该单词的次数
            count=map.get(word);
            map.put(word, count+1);
        }else{ 
            map.put(word, 1);
        }
    }
    Set<Entry<String, Integer>> entrySet = map.entrySet();
    for (Entry<String, Integer> entry : entrySet) { 
        System.out.println(entry.getKey()+"-"+entry.getValue());
    }

输出：  
`by-1`  
`Day-2`

### 如何进行排序 ###

使用Collections包装类。它包含有各种有关集合操作的静态多态方法。

//可根据指定比较器产生的顺序对指定列表进行排序。
    Collections.sort(List<T> list, Comparator<? super T> c)

示例如下：

//以上实例中的map集合为例 将map集合的每一项添加进list集合中
    List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
    Collections.sort(infos, new Comparator<Map.Entry<String, Integer>>() { 
        public int compare(Map.Entry<String, Integer> o1,
            Map.Entry<String, Integer> o2) { 
            //前者-后者 升序 后者-前者 降序
            return (o2.getValue() - o1.getValue());
        }
    });

输出：  
`Day-2`  
`by-1`

## 编程要求 ##

请仔细阅读右侧代码，根据方法内的提示，在`Begin - End`区域内进行代码补充，具体任务如下：

*  将指定文本(可以通过右侧文件目录下的`src/step3/readme.txt`查看)以降序的方式输出每个单词出现的次数。

## 测试说明 ##

补充完代码后，点击测评，平台会对你编写的代码进行测试，当你的结果与预期输出一致时，即为通过。

预期输出： 参考右边测试集中的输出。

--------------------

开始你的任务吧，祝你成功！

## 代码示例 ##

### StudentDemo.java ###

package step3;
    
    import java.util.Map;
    import java.util.HashMap;
    import java.util.StringTokenizer;
    
    public class StudentDemo { 
    	// 获取单词的数量
    	public Map<String, Integer> getWordCount(String str) { 
    		Map<String, Integer> map = new HashMap<String, Integer>();
    
    //请在此添加实现代码
    		/********** Begin **********/
    		StringTokenizer stn = new StringTokenizer(str, " ;’,?.!:\n");
    
    		while (stn.hasMoreTokens()) { 
    			String str1 = stn.nextToken();
    			if (map.containsKey(str1)) { 
    				map.put(str1, map.get(str1) + 1);
    			} else { 
    				map.put(str1, 1);
    			}
    		}
    		/********** End **********/
    
    		return map;
    	}
    }

### test.java ###

package step3;
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.util.List;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.Map;
    import java.util.Map.Entry;
    public class test{ 
    	public  static void main(String[] args) throws IOException { 
    		StudentDemo demo=new StudentDemo();
    		BufferedReader buffer=new BufferedReader(new FileReader("src/step3/readme.txt"));
    		String str="",s="";
    		while((str=buffer.readLine())!=null){ 
    			s+=str;
    		}
    		Map<String, Integer> wordCount = demo.getWordCount(s);
    		List<Entry<String, Integer>> sortWordCount = sortWordCount(wordCount);
    		for (Entry<String, Integer> entry : sortWordCount) { 
    			System.out.println(entry.getKey()+"-"+entry.getValue());
    		}
    	}
    
    	//对单词出现的次数进行排序
    	public static List<Entry<String, Integer>> sortWordCount(Map<String, Integer> map) { 
    		List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
    		Collections.sort(infos, new Comparator<Map.Entry<String,Integer>>() { 
    			@Override
    			public int compare(Entry<String, Integer> o1,
    					Entry<String, Integer> o2) { 
    				return (o2.getValue() - o1.getValue());
    			}
    		});
    		return infos;
    	}
    }

### readme.txt ###

> There are moments in life when you miss someone so much that you just want to pick them from your dreams and hug them for real! Dream what you want to dream;go where you want to go;be what you want to be,because you have only one life and one chance to do all the things you want to do.May you have enough happiness to make you sweet,enough trials to make you strong,enough sorrow to keep you human,enough hope to make you happy? Always put yourself in others’shoes.If you feel that it hurts you,it probably hurts the other person, too.The happiest of people don’t necessarily have the best of everything;they just make the most of everything that comes along their way.Happiness lies for those who cry,those who hurt, those who have searched,and those who have tried,for only they can appreciate the importance of people who have touched their lives.Love begins with a smile,grows with a kiss and ends with a tear.The brightest future will always be based on a forgotten past, you can’t go on well in lifeuntil you let go of your past failures and heartaches.