Java基础教程

文章36 |   阅读 18620 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

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

转x33g5p2x  于2021-12-18 转载在 其他  
字(6.2k)|赞(0)|评价(0)|浏览(704)

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

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

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

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

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

代码：

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

测试记录:

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

二. 练习2 字符串去重

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

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

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

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

代码:

  1. package Java_study;
  3. import java.util.HashSet;
  4. import java.util.Scanner;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-14
  10.  * @remark   课后基础练习2 字符串去重
  11.  *
  12.  */
  14. public class array_lx2 {
  15. 	public static void main(String[] args) {
  16. 		System.out.println("请输入一行字符串:");
  17. 		Scanner sc = new Scanner(System.in);
  18. 		//将输入的字符串放入chArr数组(链式编程)
  19. 		char[] chArr = sc.next().toCharArray();
  20. 		
  21. 		//创建hashSet集合对象
  22. 		HashSet<Character> hs = new HashSet<Character>();
  23. 		
  24. 		//遍历字符数组 将值插入hashSet集合
  25. 		for (int i = 0; i < chArr.length; i++) {
  26. 			hs.add(chArr[i]);
  27. 		}
  28. 		
  29. 		//输出去重后的字符
  30. 		System.out.println(hs);
  31. 	}
  33. }

测试记录:

  1. 请输入一行字符串:
  2. abdekjfiefjfowjiosjfioejfioejfie
  3. [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集合即可

代码:

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

测试记录:

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

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

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

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

代码:

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

测试记录:

  1. 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集合进行打印，打印过程中按照指定格式来进行。

代码:

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Scanner;
  6. import java.util.Set;
  8. /**
  9.  * 
  10.  * @author  只是甲
  11.  * @date    2021-07-14
  12.  * @remark  课后基础练习5 统计字符出现次数
  13.  *
  14.  */
  16. public class array_lx5 {
  17. 	public static void main(String[] args) {
  18. 		Scanner sc = new Scanner(System.in);
  19. 		//(k,v):<字符,出现字数>
  20. 		HashMap<Character, Integer> hm = new HashMap<>();
  21. 		System.out.println("请输入一个字符串");
  22. 		String str = sc.next();
  23. 		
  24. 		char[] chs = str.toCharArray();
  25. 		
  26. 		for (char ch : chs) {
  27. 			//如果已包含这个key 则value加1后重新放入map，如果不包含，则放入该字符，并给value值为1
  28. 			hm.put(ch, hm.containsKey(ch) ? hm.get(ch) + 1 : 1);
  29. 		}
  30. 		Set<Map.Entry<Character, Integer>> esSet = hm.entrySet();
  31. 		for (Map.Entry<Character, Integer> me : esSet) {
  32. 			//HashMap存取顺序随机，不一致
  33.             //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)
  34. 			System.out.println(me.getKey() + "(" + me.getValue() + ")");
  35. 		}
  36. 	}
  38. }

测试记录:

  1. 请输入一个字符串
  2. wojfioejfiowefjwofjwiofajeifojwefiojcmoaj99weijowfijef123r3fwf311232445354546242343243
  3. a(2)
  4. c(1)
  5. e(6)
  6. f(11)
  7. i(7)
  8. j(10)
  9. m(1)
  10. o(9)
  11. 1(3)
  12. 2(6)
  13. r(1)
  14. 3(8)
  15. 4(7)
  16. 5(3)
  17. 6(1)
  18. w(8)
  19. 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并打印结果

代码:

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author  只是甲
  10.  * @date    2021-07-14
  11.  * @remark  课后基础练习6 分割字符串并计数
  12.  *
  13.  */
  15. public class array_lx6 {
  16. 	public static void main(String[] args) {
  17. 		String s = "If you want to change your fate I think you must come to the dark horse to learn java";
  18. 		String[] splitStr = s.split(" ");
  19. 		
  20. 		HashMap<String, Integer> hm = new HashMap<>();
  21. 		for (String str :  splitStr) {
  22. 			hm.put(str, hm.containsKey(str) ? hm.get(str) + 1 : 1);
  23. 		}
  24. 		
  25. 		//遍历hm集合
  26. 		Set<Map.Entry<String, Integer>> esSet = hm.entrySet();
  27. 		//将遍历结果进行拼接
  28. 		StringBuilder sb = new StringBuilder("{");
  29. 		//拼接时计数
  30. 		int count = 0;
  31. 		for (Map.Entry<String, Integer> me : esSet) {
  32. 			// 每5个元素换行一次
  33. 			if (count >= 5) {
  34. 				sb.append("\r\n");
  35. 				count = 0;
  36. 			}
  37. 			count++;
  38. 			//拼接当前(k,v)值
  39. 			sb.append("[" + me.getKey() + " = " + me.getValue() + "]、");
  40. 		}
  41. 		//去掉最后一个多余的顿号
  42. 		String temp = sb.substring(0, sb.length() -1).toString();
  43. 		sb.delete(0, sb.length()).append(temp).append("}");
  44. 		
  45. 		System.out.println(sb);
  46. 	}
  48. }

测试记录：

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

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/116042907

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/120308965

内容来源于网络，如有侵权，请联系作者删除！

Java数组集合排序去重

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com