Java基础系列32-数组、集合练习

柔情只为你懂 2022-09-11 10:13 204阅读 0赞

### 文章目录 ###

*  一. 练习1 int数组去重排序
 *  二. 练习2 字符串去重
 *  三.练习3 生成不重复随机数字
 *  四. 练习4 生成不重复随机字符串
 *  五. 练习5 统计字符出现次数
 *  六. 练习6 分割字符串并计数
 *  参考:

# 一. 练习1 int数组去重排序 #

**需求：**  
 分析以下需求，并用代码实现：  
  1. 定义一个长度为10的int数组,并存入10个int类型的数据,其中有一些数据是重复的  
  2. 利用集合的知识对数组进行去重,产生新数组,不能改变数组中原来数字的大小顺序  
  3. 打印新数组中的内容按照以下描述完成类的定义。  
  一定要注意:不能改变数组中原来数字的大小顺序

**分析：**  
  只有一种元素，所以使用单例Collection即可

Collection接口 – List（接口，可重复，存取顺序一致） 、 Set（接口，唯一，存取顺序不一致）  
    List接口 – ArrayList(实现类，数据结构为数组)、LinkedList(实现类，数据结构为链表)  
    Set接口 – HashSet(实现类)

因为不能改变顺序，所以不能用Set接口，所以选择ArrayList或LinkedList

代码：

package Java_study;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  课后基础练习1 int数组去重排序
     *
     */
    
    public class array_lx1 {
    	public static void main(String[] args) {
    		//定义一个数组 其中33 22 出现过2次
            int[] arr = {33, 22, 11, 33, 15, 66, 88, 22, 10, 97};
            
            //定义一个ArrayList集合，用于存储去重后的int数组
            ArrayList<Integer> arrayList = new ArrayList<>();
            
            //遍历数组 arr.for
            for (int i : arr) {
            	//如果数组中不存在该元素，则加入该集合
            	if (!arrayList.contains(i)) {
            		arrayList.add(i);
            	}
            }
            
            //创建新数组，长度等于集合的长度
            int[] arrSort = new int[arrayList.size()];
            
            //对新数组元素进行赋值
            for (int i = 0; i < arrayList.size(); i++) {
            	arrSort[i] = arrayList.get(i);
            }
            System.out.println(Arrays.toString(arrSort));
    	}
    
    }

测试记录:

[33, 22, 11, 15, 66, 88, 10, 97]

# 二. 练习2 字符串去重 #

**需求：**  
键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符

**分析：**  
 只有一种元素，所以使用单例Collection即可

Collection接口 – List（接口，可重复，存取顺序一致） 、 Set（接口，唯一，存取顺序不一致）  
  List接口 – ArrayList(实现类，数据结构为数组)、LinkedList(实现类，数据结构为链表)  
  Set接口 – HashSet(实现类)

因为仅需要去重，不要求顺序，所以使用HashSet即可自动去重，  
 需要使用String.toCharArray将字符串拆解成char类型放入数组  
 注意char类型的包装类是Character

**代码:**

package Java_study;
    
    import java.util.HashSet;
    import java.util.Scanner;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark   课后基础练习2 字符串去重
     *
     */
    
    public class array_lx2 {
    	public static void main(String[] args) {
    		System.out.println("请输入一行字符串:");
    		Scanner sc = new Scanner(System.in);
    		//将输入的字符串放入chArr数组(链式编程)
    		char[] chArr = sc.next().toCharArray();
    		
    		//创建hashSet集合对象
    		HashSet<Character> hs = new HashSet<Character>();
    		
    		//遍历字符数组 将值插入hashSet集合
    		for (int i = 0; i < chArr.length; i++) {
    			hs.add(chArr[i]);
    		}
    		
    		//输出去重后的字符
    		System.out.println(hs);
    	}
    
    }

**测试记录:**

请输入一行字符串:
    abdekjfiefjfowjiosjfioejfioejfie
    [a, b, s, d, e, f, w, i, j, k, o]

# 三.练习3 生成不重复随机数字 #

**需求：**  
 产生10个1-20之间的随机数要求随机数不能重复

**分析：**  
 只有一种元素，所以使用单例Collection即可

Collection接口 – List（接口，可重复，存取顺序一致） 、 Set（接口，唯一，存取顺序不一致）  
  List接口 – ArrayList(实现类，数据结构为数组)、LinkedList(实现类，数据结构为链表)  
  Set接口 – HashSet(实现类)  
 nextInt(int x)则会生成一个范围在0~x（不包含X）内的任意正整数  
  生成1-20则需要 nextint(20)+1  
 不能重复的数，则放入HashSet集合即可

**代码:**

package Java_study;
    
    import java.util.HashSet;
    import java.util.Random;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark   课后基础练习3 生成不重复随机数字
     *
     */
    
    public class array_lx3 {
    	public static void main(String[] args) {
    		HashSet<Integer> hs = new HashSet<>();
    		Random r = new Random();
    		
    		//hs小于10个元素则一直声称随机数插入hs集合
    		while (hs.size() < 10) {
    			hs.add(r.nextInt(20) + 1);
    		}
    		
    		//打印结果
    		System.out.println("hs.size():" + hs.size());
    		System.out.println("hs:" + hs);
    	}
    
    }

**测试记录:**

hs.size():10
    hs:[17, 18, 20, 4, 6, 8, 9, 10, 12, 14]

# 四. 练习4 生成不重复随机字符串 #

**需求：**  
  产生10个长度为10的不能重复的字符串(里面只能出现大写字母、小写字母、0-9的数字)，并遍历打印输出

**分析：**  
  需要先创建一个字符库，包含所有符合规范的字符 a-z A-Z 0-9,再从这个库中随机取出10个值拼接成为字符串

**代码:**

package Java_study;
    
    import java.util.Random;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  生成不重复随机字符串
     *
     */
    
    public class array_lx4 {
    	public static void main(String[] args) {
    		Random r = new Random();
    		String charList = "qwertyuiopasdfghjklzxcvvbnmQWERTYUIOPASDFGHJKLZXCVVBNM1234567890";
    		StringBuilder result = new StringBuilder();
    		for (int i = 0; i < 10; i++) {
    			//每次从charList随机取出一个字符拼接到result字符串（随机数字大小等于字符库长度）
    			result.append(charList.charAt(r.nextInt(charList.length())));
    		}
    		//打印结果
    		System.out.println(result);
    	}
    
    }

**测试记录:**

sqMfoFbQZz

# 五. 练习5 统计字符出现次数 #

**需求：**

1.  利用键盘录入，输入一个字符串
2.  统计该字符串中各个字符的数量(提示:字符不用排序)
3.  如：  
    用户输入字符串"If~you-want~to~change-your\_fate\_I\_think~you~must~come-to-the-dark-horse-to-learn-java"  
    程序输出结果：-(9)I(2)\_(3)a(7)c(2)d(1)e(6)f(2)g(1)h(4)i(1)j(1)k(2)l(1)m(2)n(4)o(8)r(4)s(2)t(8)u(4)v(1)w(1)y(3)~(6)
    
    字符 — 次数

**思路：**

1.  创建map集合，键为Character，值为Integer
2.  键盘录入字符串 str
3.  将字符串转换为字符数组，并遍历这个字符数组，获取每个字符
4.  在循环中判断集合中map集合中的键是否包含这个字符，如果map集合中的键不包含这个字符，那么就让map执行put方法，键就是遍历到的字符，值为1  
    如果map集合中包含这个键，就让map集合的值 + 1存储
5.  循环完毕后，遍历map集合进行打印，打印过程中按照指定格式来进行。

**代码:**

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Scanner;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  课后基础练习5 统计字符出现次数
     *
     */
    
    public class array_lx5 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		//(k,v):<字符,出现字数>
    		HashMap<Character, Integer> hm = new HashMap<>();
    		System.out.println("请输入一个字符串");
    		String str = sc.next();
    		
    		char[] chs = str.toCharArray();
    		
    		for (char ch : chs) {
    			//如果已包含这个key 则value加1后重新放入map，如果不包含，则放入该字符，并给value值为1
    			hm.put(ch, hm.containsKey(ch) ? hm.get(ch) + 1 : 1);
    		}
    		Set<Map.Entry<Character, Integer>> esSet = hm.entrySet();
    		for (Map.Entry<Character, Integer> me : esSet) {
    			//HashMap存取顺序随机，不一致
                //I(2) _(3) a(7) c(2) d(1) e(6) f(2) g(1) h(4) i(1) j(1) k(2) l(1) -(9) m(2) n(4) o(8) r(4) s(2) t(8) u(4) v(1) w(1) y(3) ~(6)
    			System.out.println(me.getKey() + "(" + me.getValue() + ")");
    		}
    	}
    
    }

**测试记录:**

请输入一个字符串
    wojfioejfiowefjwofjwiofajeifojwefiojcmoaj99weijowfijef123r3fwf311232445354546242343243
    a(2)
    c(1)
    e(6)
    f(11)
    i(7)
    j(10)
    m(1)
    o(9)
    1(3)
    2(6)
    r(1)
    3(8)
    4(7)
    5(3)
    6(1)
    w(8)
    9(2)

# 六. 练习6 分割字符串并计数 #

**需求：**

1.  统计每个单词出现的次数
2.  有如下字符串"If you want to change your fate I think you must come to the dark horse to learn java"(用空格间隔)
3.  打印结果：

**分析：**

1.  分割字符串 => String.split
2.  分割后的字符串放入String\[\]数组
3.  将字符串，数量放入Map中(k,v) k=字符串 v=字符串出现次数
4.  遍历String\[\]放入map，每次放入前判断是否存在该字符串  
    存在则出现次数记为现有值+1  
    不存在则出现次数记为1
5.  遍历map并打印结果

**代码:**

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  课后基础练习6 分割字符串并计数
     *
     */
    
    public class array_lx6 {
    	public static void main(String[] args) {
    		String s = "If you want to change your fate I think you must come to the dark horse to learn java";
    		String[] splitStr = s.split(" ");
    		
    		HashMap<String, Integer> hm = new HashMap<>();
    		for (String str :  splitStr) {
    			hm.put(str, hm.containsKey(str) ? hm.get(str) + 1 : 1);
    		}
    		
    		//遍历hm集合
    		Set<Map.Entry<String, Integer>> esSet = hm.entrySet();
    		//将遍历结果进行拼接
    		StringBuilder sb = new StringBuilder("{");
    		//拼接时计数
    		int count = 0;
    		for (Map.Entry<String, Integer> me : esSet) {
    			// 每5个元素换行一次
    			if (count >= 5) {
    				sb.append("\r\n");
    				count = 0;
    			}
    			count++;
    			//拼接当前(k,v)值
    			sb.append("[" + me.getKey() + " = " + me.getValue() + "]、");
    		}
    		//去掉最后一个多余的顿号
    		String temp = sb.substring(0, sb.length() -1).toString();
    		sb.delete(0, sb.length()).append(temp).append("}");
    		
    		System.out.println(sb);
    	}
    
    }

**测试记录：**

{[think = 1]、[fate = 1]、[learn = 1]、[want = 1]、[change = 1]、
    [I = 1]、[come = 1]、[your = 1]、[the = 1]、[horse = 1]、
    [java = 1]、[dark = 1]、[must = 1]、[to = 3]、[If = 1]、
    [you = 2]}

# 参考: #

1.  https://blog.csdn.net/qq\_43529621/article/details/116042907