Java 集合练习

发表于 分类于 阅读次数： 本文字数： 525 阅读时长 ≈ 2 分钟

OOP h09

  • 不可以修改类的名字、包名、和固有的几个方法名以及方法的可见性
  • 可以增加其他方法、属性、类
  • 可以引用 jdk 的类
  • 不要引用 jdk1.8 以外第三方的包
1
import java.util.*;

0x00 getDistinctCharCount

计算出一段文字中不重复的字符的个数，例如“北京市北京大学”不重复字符为 5

提示：使用 java.util.HashSet

集合中的元素是无序的，唯一的。利用集合的这个特性去存储一个数组，得到的将是互不重复的元素，由此可计算不同元素的个数。

1
2
3
4
5
6
7
8
public int getDistinctCharCount(String s) {
	Set<Character> set = new HashSet<>();
	char[] chars = s.toCharArray();
	for (char cha : chars) {
		set.add(cha);
	}
	return set.size();
}

0x01 getFrequentChar

返回一段文字中，出现频率最高的字符（不考虑并列第一的情况）

  • 例如：getFrequentChar("好好学习") 返回 '好'
  • 例如：getFrequentChar("我是xx大学软件学院学生") 返回 '学'

提示：使用一个长度为 65535 的数组，或者使用 HashMap

自然的想法：

  1. 记录每一个字符出现的次数
  2. 找到最大的次数
  3. 找到最大次数对应的字符

可以利用 HashMap，创建键值对，字符为键，出现次数为值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
	public char getFrequentChar(String s) {
		int i, max;
+		char ans = 0;
		// 1.记录每一个字符出现的次数
		HashMap<Character, Integer> map = new HashMap<>();// 创建哈希映射
		for (i = 0; i < s.length(); i++) {
			char cha = s.charAt(i);// s中按字符存储
			if (!map.containsKey(cha)) {// 这个字符没存
				map.put(cha, 1);// 出现次数为1
			} else {// 这个字符存过了
				map.put(cha, map.get(cha) + 1);// 出现次数加1
			}
		}

		// 2.找到最大的次数
		max = 0;
		Set<Character> characterSet = map.keySet();// 所有不重复字符的集合
		for (Character cha: characterSet) {// 遍历
-			max = max > map.get(cha) ? max : map.get(cha);// 找到最大值
+			if (max < map.get(cha)) {
+				max = map.get(cha);
+				ans = cha;
+			}
		}

		// 3.找到最大次数对应的字符
-		Set<Map.Entry<Character, Integer>> entries = map.entrySet();// 所有键值对的集合
-		for (Map.Entry<Character, Integer> entry : entries) {// 遍历
-			if (entry.getValue().equals(max)) {// 这个键值对的值是最大值，字符为出现最多的字符
-				return entry.getKey();// 返回键，即字符
-			}
-		}
-		return ' ';// 默认返回空格
+		return ans;
	}

0x02 getFrequentWord

返回一段文字中，出现频率最高的词（每个词由2个字符构成，任意两个相邻的字符称为一个词，例如“xx大学，你好”由“xx”“x大”“大学”“学，”“，你”“你好” 6 个词构成）

不会出现频率最高并列的情况

提示：使用 HashMap

同上，字符换成两个字符组成的子串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
	public String getFrequentWord(String content){
		int i, max;
+		String ans = null;
		HashMap<String, Integer> map = new HashMap<>();
-		for (i = 0; i < content.length() - 2; i++) {
+		for (i = 0; i < content.length() - 1; i++) {
			String str = content.substring(i, i + 2);
			if (!map.containsKey(str)) {
				map.put(str, 1);
			} else {
				map.put(str, map.get(str) + 1);
			}
		}
		max = 0;
		Set<String> stringSet = map.keySet();
		for (String str: stringSet) {
-			max = max > map.get(str) ? max : map.get(str);
+			if (max < map.get(str)) {
+				max = map.get(str);
+				ans = str;
+			}
		}
-		Set<Map.Entry<String, Integer>> entries = map.entrySet();
-		for (Map.Entry<String, Integer> entry : entries) {
-			if (entry.getValue().equals(max)) {
-				return entry.getKey();
-			}
-		}
-		return null;
+		return ans;
	}

2021.3.23 更新

这样做是不可以的，第 4 行遍历少了一个字符。

应 i < content.length() - 1。

0x03 zipStringBufer

把一个 StringBufer 中所有的空格去掉

提示：不能新建 StringBuffer 对象，必须在原来的基础上删掉原来字符串

找到空格，删除它。

1
2
3
4
5
6
7
8
9
	public void zipStringBufer(StringBuffer buf) {
		int i;
		for (i = 0; i < buf.length(); i++) {
			if (buf.charAt(i) == ' ') {
-				buf.deleteCharAt(i);
+				buf.deleteCharAt(i--);
			}
		}
	}

2021.3.23 更新

这样做是不可以的，删除字符之后索引值会发生改变，导致跳过一些可能是空格的字符。

应 i--。

0x04 完整代码

不完整

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package com.huawei.classroom.student.h09;

import java.util.*;

/**
 * 把你作业的代码写到这个类里面
 * 不可以修改类的名字、包名、和固有的几个方法名以及方法的可见性
 * 可以增加其他方法、属性、类
 * 可以引用jdk的类
 * 不要引用jdk1.8以外第三方的包
 *
 * @author super
 *
 */
public class Home09 {
	public Home09() {
		// TODO Auto-generated constructor stub
	}
	/**
	 * 计算出一段文字中不重复的字符的个数，例如“北京市北京大学 ”不重复字符为5
	 * 提示：使用java.util.HashSet
	 * 难度系数1星
	 * @param s
	 * @return
	 */
	public int getDistinctCharCount(String s) {
		Set<Character> set = new HashSet<>();
		char[] chars = s.toCharArray();
		for (char cha : chars) {
			set.add(cha);
		}
		return set.size();
	}
	/**
	 * 返回一段文字中，出现频率最高的字符（不考虑并列第一的情况） 例如：getFrequentChar("好好学习") 返回'好'
	 * 例如：getFrequentChar("我是xx大学软件学院学生") 返回'学'
	 * 提示：使用一个长度为65535的数组，或者使用HashMap
	 * 难度系数2星
	 * @param s
	 * @return
	 */
	public char getFrequentChar(String s) {
		int i, max;
		HashMap<Character, Integer> map = new HashMap<>();
		for (i = 0; i < s.length(); i++) {
			char cha = s.charAt(i);
			if (!map.containsKey(cha)) {
				map.put(cha, 1);
			} else {
				map.put(cha, map.get(cha) + 1);
			}
		}
		max = 0;
		Set<Character> characterSet = map.keySet();
		for (Character cha: characterSet) {
			max = max > map.get(cha) ? max : map.get(cha);
		}
		Set<Map.Entry<Character, Integer>> entries = map.entrySet();
		for (Map.Entry<Character, Integer> entry : entries) {
			if (entry.getValue().equals(max)) {
				return entry.getKey();
			}
		}
		return ' ';
	}



	/**
	 * 返回一段文字中，出现频率最高的词（每个词由2个字符构成，任意两个相邻的字符称为一个词，例如“xx大学，你好”由“xx”“x大”“大学”“学，”“，你”“你好” 6个词构成)
	 * 不会出现频率最高并列的情况
	 * 提示：使用HashMap
	 * 难度系数2星
	 * @param content
	 * @return
	 */
	public String getFrequentWord(String content){
		int i, max;
		HashMap<String, Integer> map = new HashMap<>();
		for (i = 0; i < content.length() - 2; i++) {
			String str = content.substring(i, i + 2);
			if (!map.containsKey(str)) {
				map.put(str, 1);
			} else {
				map.put(str, map.get(str) + 1);
			}
		}
		max = 0;
		Set<String> stringSet = map.keySet();
		for (String str: stringSet) {
			max = max > map.get(str) ? max : map.get(str);
		}
		Set<Map.Entry<String, Integer>> entries = map.entrySet();
		for (Map.Entry<String, Integer> entry : entries) {
			if (entry.getValue().equals(max)) {
				return entry.getKey();
			}
		}
		return null;
	}



	/**
	 * 把一个StringBufer中所有的空格去掉
	 * 提示：不能新建StringBuffer对象，必须在原来的基础上删掉原来字符串
	 * 难度系数1星
	 * @param buf
	 */
	public void zipStringBufer(StringBuffer buf) {
		int i;
		for (i = 0; i < buf.length(); i++) {
			if (buf.charAt(i) == ' ') {
				buf.deleteCharAt(i);
			}
		}
	}


}

0x05 Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.huawei.classroom.student.h09;


/**
 *
 * 不要引用jdk1.8以外第三方的包
 *
 *
 */
public class Test {

	public Test() {
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {

		// TODO Auto-generated method stub
		//完成Home09的代码 使得下列代码能够编译 并且通过测试用例
		Home09 util=new  Home09();
		if(util.getDistinctCharCount("北京市北京大学")==5) {
			System.out.println("getDistinctCharCount ok");
		}
		if(util.getFrequentChar("我是xx大学软件学院学生")=='学') {
			System.out.println("getFrequentChar ok");
		}

		if(util.getFrequentWord("北京市北京大学").equals("北京")) {
			System.out.println("getFrequentWord ok");
		}
		StringBuffer buf=new StringBuffer("a b c ");
		util.zipStringBufer(buf);
		if(buf.toString().equals("abc") ) {
			System.out.println("zipStringBufer ok");
		}
	}

}