Java集合(四)

2年前 阅读 388 评论 0 赞 1

Java集合(四)

1. 简单练习HashSet集合-产生1到20,10个不重复的随机数
  1. //1.创建Random对象
  2. Random r = new Random();
  3. //2.因为存储不重复的,我们用HashSet集合
  4. //这里泛型为什么用Integer知道吗!
  5. HashSet<Integer> hs = new HashSet<>();
  6. //3.循环条件hs.size()<10;
  7. while (hs.size() < 10){
  8. //4.通过Random方法获取随机数
  9. //r.nextInt(20):获取到的是0到19的随机数--左开右闭的
  10. hs.add(r.nextInt(20) + 1);
  11. }
  12. System.out.println(hs);
2. 集合小练习
  1. #练习一:
  2. //需求:使用Scanner输入,去掉输入中的重复字符,打印不同的字符
  3. //1.创建Scanner对象
  4. Scanner sc = new Scanner(System.in);
  5. System.out.println("请输入一串字符:");
  6. //2.创建hashSet对象
  7. HashSet<Character> hs = new HashSet<>();
  8. //3.用字符串接收这个输入值,并将字符串转为字符数组
  9. String str = sc.nextLine();
  10. char[] arr = str.toCharArray();
  11. //4.遍历字符数组并加入到hs中
  12. for (Character c : arr){
  13. hs.add(c);
  14. }
  15. System.out.println(hs);
  16. #练习二:
  17. //需求:给有重复元素的ArrayList集合创建一个去重方法,直接调用就好
  18. ArrayList<String> list = new ArrayList<>();
  19. list.add("tmac");
  20. list.add("tmac");
  21. list.add("kobe");
  22. list.add("kobe");
  23. list.add("kg");
  24. list.add("kg");
  25. list.add("jiangjun");
  26. list.add("jiangjun");
  27. System.out.println(list);
  28. System.out.println("去重之前的值");
  29. //调用封装的去重方法
  30. cancelReptList(list);
  31. System.out.println(list);
  32. System.out.println("去重之后的值");
  33. }
  34. //封装的去重方法
  35. public static void cancelReptList(List<String> list){
  36. //1.创建LinkedHashSet对象,这里面不能存储重复值
  37. LinkedHashSet<String> hs = new LinkedHashSet<>();
  38. //2.将list加到hs中,就可以在hs中去除重复值了
  39. hs.addAll(list);
  40. //3.将list清空
  41. list.clear();
  42. //4.将去重后的hs加入到list中
  43. list.addAll(hs);
  44. }
3. TreeSet集合的简单使用
  1. //1.TreeSet集合是对元素进行排序且保证元素唯一的
  2. //只用LinkedHashSet是保证怎么存就怎么取,且去重的
  3. TreeSet<Integer> ts = new TreeSet<>();//从小到大排序
  4. ts.add(78);
  5. ts.add(45);
  6. ts.add(109);
  7. ts.add(23);
  8. ts.add(12);
  9. System.out.println(ts);
  10. //2.TreeSet集合存储自定义对象
  11. TreeSet<Student> ts1 = new TreeSet<>();
  12. ts1.add(new Student("tmac",23));
  13. ts1.add(new Student("kobe",13));
  14. ts1.add(new Student("king",34));
  15. ts1.add(new Student("jiangjun",45));
  16. //我们存储的是自定义对象,TreeSet是对元素排序的,我们看看会怎么回事
  17. System.out.println(ts1);
  18. //报错崩溃:java.lang.ClassCastException:类型无法匹配。我们解决方法是
  19. //实现一个compable接口,就是要告诉TreeSet按照什么要求对Student排序
  20. //延展:
  21. //TreeSet底层是二叉树结构
4. Map集合的概述和特点和iOS的字典很像
  1. //1.创建一个map
  2. Map<String,Integer> map = new HashMap<>();
  3. //添加元素的方法put--put方法是有返回值的,返回值就是这个值的类型
  4. Integer i1 = map.put("tmac",19);
  5. map.put("kobe",37);
  6. map.put("kiii",98);
  7. map.put("kdjf",88);
  8. Integer i2 = map.put("tmac",39);
  9. System.out.println(map);//看这个打印发现键和值是对应的,但是打印出来顺序是无序的
  10. System.out.println(i1);
  11. System.out.println(i2);
  12. //对比i1和i2的打印值,说明我们呢put方法的返回值只返回被覆盖的键对应的值
  13. //在Map中键的值是唯一的,我们重复为一个键添加值,就会覆盖原有值,并返回
  14. System.out.println("1---------------------");
  15. //2.根据键删除值,返回被删除的值
  16. Integer i3 = map.remove("tmac");
  17. System.out.println(i3);
  18. map.put("jj",45);
  19. map.put("cc",44);
  20. //根据键和值删除,返回删除成功与否
  21. boolean b1 = map.remove("jj",45);
  22. System.out.println(b1);
  23. System.out.println("2------------------");
  24. //3.清除所有元素
  25. // map.clear();
  26. //4.判断功能
  27. //map.containsKey():是否包含这个key
  28. //map.containsValue():是否包含这个值
  29. map.isEmpty();//是否为空
  30. //5.获取集合中所有的值
  31. Collection<Integer> c = map.values();
  32. System.out.println(c);
  33. //6.map.size():元素个数--一对键值才是一个长度
5. Map集合的遍历—键找值
  1. //1. Map集合遍历--键找值(map中没有迭代器)
  2. Map<String,Integer> map = new HashMap<>();
  3. map.put("jj",67);
  4. map.put("ji",45);
  5. map.put("qq",32);
  6. map.put("aa",13);
  7. map.put("cc",38);
  8. //根据键获取值
  9. //Integer i = map.get("jj");
  10. //第一种遍历方法
  11. //获取所有键的集合
  12. Set<String> keySet = map.keySet();//这个set集合中就有迭代器了
  13. Iterator<String> it = keySet.iterator();
  14. while (it.hasNext()){
  15. String str = it.next();
  16. Integer i1 = map.get(str);
  17. System.out.println(i1);
  18. }
  19. System.out.println("-----------------------");
  20. //第二种 增强for循环遍历
  21. for (String str : map.keySet()){
  22. Integer i2 = map.get(str);
  23. System.out.println(i2);
  24. }
6. Map使用键值对对象找键和值
  1. //Map集合键值对对象找键和值
  2. Map<String,String> map = new HashMap<>();
  3. map.put("jj","maidi");
  4. map.put("qq","tmac");
  5. map.put("bb","kobe");
  6. map.put("vv","king");
  7. map.put("cc","polo");
  8. System.out.println(map);
  9. //获取键值对对象
  10. //Map.Entry说明Entry是Map的内部接口
  11. Set<Map.Entry<String,String>> entrySet = map.entrySet();
  12. System.out.println(entrySet);//现在打印出来和这个map是一样的
  13. //利用迭代器来遍历entrySet
  14. Iterator<Map.Entry<String,String>> it = entrySet.iterator();
  15. while (it.hasNext()){
  16. //获得每一个entry对象
  17. Map.Entry<String,String> en = it.next();
  18. //获取key和值
  19. String key = en.getKey();
  20. String value = en.getValue();
  21. System.out.println(key);
  22. System.out.println(value);
  23. }
  24. System.out.println("下面是增强for循环的结果");
  25. //用增强for循环解决
  26. for (Map.Entry<String,String> en : entrySet){
  27. String key = en.getKey();
  28. String value = en.getValue();
  29. System.out.println(key);
  30. System.out.println(value);
  31. }
7. LinkedHashMap
  1. //LinkedHashMap
  2. LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
  3. lhm.put("t",3);
  4. lhm.put("j",5);
  5. lhm.put("w",2);
  6. lhm.put("i",5);
  7. System.out.println(lhm);
  8. //打印出来发现是怎么存怎么取的
8.
  1. //TreeMap集合--第一种比较,重写自定义类的方法
  2. TreeMap<Student,String> tm = new TreeMap<>();
  3. tm.put(new Student("tmac",19),"成都");
  4. tm.put(new Student("tma",123),"上海");
  5. tm.put(new Student("tm",13),"北京");
  6. tm.put(new Student("t",18),"广州");
  7. System.out.println(tm);
  8. //在这里打印tm是会报错的,因为TreeMap会对这个键进行排序,现在
  9. //我们的键是自定义的学生对象,所以不知道怎么排序,所以我们要去在自定义类中
  10. //去实现这个Comparable接口
  11. //这样还是比较复杂的,我们有传比较器的构造方法
  12. System.out.println("1----------------------");
  13. #自定义类中的操作
  14. public class Student implements Comparable<Student> //实现接口
  15. //重写接口中的方法
  16. //实现这个Comparable<Student>接口,告诉这个TreeMap怎么去比较这个Student
  17. @Override
  18. public int compareTo(Student s) {
  19. int num = this.age - s.age;
  20. return num == 0 ? this.name.compareTo(s.name) : num;
  21. //以比较年龄为主要条件,姓名为次要条件
  22. }
  23. #第二种比较方法—传入匿名内部类
  24. //在我们创建这个tm1时,就传一个匿名内部类,并重写里面的方法
  25. TreeMap<Student,String> tm1 = new TreeMap<>(new Comparator<Student>() {
  26. @Override
  27. public int compare(Student o1, Student o2) {
  28. int num = o1.getName().compareTo(o2.getName());//前面这个比较是按照码表值比较的(可以传入中文试试)
  29. return num == 0 ? o1.getAge() - o2.getAge() : num;//首要按姓名排序,其次年龄
  30. }
  31. });
  32. tm1.put(new Student("蒋介石",19),"成都");
  33. tm1.put(new Student("曾国藩",89),"上海");
  34. tm1.put(new Student("易中天",13),"北京");
  35. tm1.put(new Student("邋遢大王",18),"广州");
  36. System.out.println(tm1);
9. 统计字符串中字符出现的次数
  1. //小练习--统计字符串中字符出现的次数
  2. //1.定义一个字符串
  3. String str = "aaaaaahhhhhhhbbbbbbbddddddduuuuuuiiiiiiii";
  4. //2.将字符串转为字符数组
  5. char[] charr = str.toCharArray();
  6. //3.定义双列集合,存储字符串及字符串出现的次数
  7. HashMap<Character,Integer> hs = new HashMap<>();
  8. //4.遍历字符数组中所有字符,并将每个字符存入集合中
  9. for (char c : charr){
  10. //存储过程中要判断,如果集合中不包含这个key,就将键和值存入,且值为1.如果包含,就将值加1
  11. // if (!hs.containsKey(c)){
  12. // hs.put(c,1);
  13. // }else{
  14. // hs.put(c, hs.get(c) + 1);
  15. // }
  16. hs.put(c, hs.containsKey(c) ? hs.get(c) + 1 : 1 );
  17. //三目运算符:表达式? 结果1 : 结果2 (表达式为真,执行结果1,否则执行结果2)
  18. }
  19. System.out.println(hs);
10. HashMap嵌套HashMap
  1. //HashMap嵌套HashMap
  2. //定义一个班级
  3. HashMap<Student, String> hm88 = new HashMap<>();
  4. hm88.put(new Student("孙悟空", 23), "fd");
  5. hm88.put(new Student("泰森", 24), "dd");
  6. hm88.put(new Student("麦斯", 25), "dd");
  7. hm88.put(new Student("科比", 26), "fgd");
  8. //定义另一个班级
  9. HashMap<Student, String> hm99 = new HashMap<>();
  10. hm99.put(new Student("Ã∆…Æ", 1023), "±±æ©");
  11. hm99.put(new Student("ÀÔŒÚø’",1024), "±±æ©");
  12. hm99.put(new Student("÷Ì∞ÀΩ‰",1025), "…œ∫£");
  13. hm99.put(new Student("…≥∫Õ…–",1026), "π„÷›");
  14. //再定义一个HashMap来存,注意键--就是HashMap
  15. HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
  16. hm.put(hm88, "µ⁄88∆⁄ª˘¥°∞‡");
  17. hm.put(hm99, "µ⁄99∆⁄ª˘¥°∞‡");
  18. //遍历
  19. for(HashMap<Student, String> h : hm.keySet()) {
  20. String value = hm.get(h);
  21. for(Student key : h.keySet()) {
  22. String value2 = h.get(key);
  23. System.out.println(key + "=" + value2 + "=" + value);
  24. }
  25. }
11. HashMap和Hashtable的简单区别
  1. //HashMap和Hashtable的区别
  2. /*共同点:底层都是hash算法,都是双列集合
  3. 不同点:
  4. HashMap:是线程不安全的,效率高
  5. 2.可以存储null键和null值
  6. Hashtable:是线程安全的,效率低
  7. 2.不能存储null键和null值
  8. */
12. 集合框架Collections工具类简单使用
  1. //集合框架Collections工具类
  2. /*
  3. public static <T> void sort(List<T> list):排序
  4. public static <T> int binarySearch(List<?> list,T key):二分查找法
  5. public static <T> T max(Collection<?> coll):获取最大值
  6. public static void reverse(List<?> list)
  7. public static void shuffle(List<?> list)
  8. */
  9. //1.排序
  10. ArrayList<String> list = new ArrayList<>();
  11. list.add("d");
  12. list.add("c");
  13. list.add("a");
  14. list.add("b");
  15. System.out.println(list);//ArrayList是怎么存怎么取的
  16. System.out.println("排序之后");
  17. //集合工具类Collections的类方法
  18. Collections.sort(list);
  19. System.out.println(list);
  20. System.out.println("1-------------------------");
  21. //2.二分查找法--根据值返回值在集合中的索引
  22. //我们用个有序的集合
  23. ArrayList<String> list1 = new ArrayList<>();
  24. list1.add("a");
  25. list1.add("c");
  26. list1.add("e");
  27. list1.add("g");
  28. list1.add("k");
  29. list1.add("m");
  30. list1.add("y");
  31. int num = Collections.binarySearch(list1,"c");
  32. int num1 = Collections.binarySearch(list1,"k");
  33. System.out.println(num);
  34. System.out.println(num1);
  35. System.out.println("2------------------------------");
  36. //3. 获取最大值
  37. String str = Collections.max(list1);
  38. System.out.println(str);
  39. System.out.println("3-------------------------------");
  40. //4. 反转
  41. Collections.reverse(list1);
  42. System.out.println(list1);
  43. System.out.println("4--------------------------------");
  44. //5. 洗牌--打乱
  45. Collections.shuffle(list1);
  46. System.out.println(list1);
13. 斗地主随机发牌实现
  1. //斗地主发牌小游戏
  2. //1.创建一个集合对象,将所有扑克存进去
  3. //牌号
  4. String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
  5. //花色
  6. String[] color = {"红桃","黑桃","方片","梅花"};
  7. ArrayList<String> poker = new ArrayList<>();
  8. //拼接花色和数字
  9. for (String s1 : color){
  10. for (String s2 : num){
  11. //拼接
  12. String s3 = s1.concat(s2);
  13. poker.add(s3);//一副扑克的基本骨架有了
  14. }
  15. }
  16. //System.out.println(poker);
  17. //添加大小王
  18. poker.add("小王");
  19. poker.add("大王");
  20. System.out.println(poker.size());
  21. //2.洗牌
  22. Collections.shuffle(poker);
  23. //3.发牌--我们需要三个集合当做三个玩家的牌,创建一个集合作为底牌的集合
  24. ArrayList<String> tmac = new ArrayList<>();
  25. ArrayList<String> kobe = new ArrayList<>();
  26. ArrayList<String> mine = new ArrayList<>();
  27. ArrayList<String> dipai = new ArrayList<>();
  28. //for循环发牌
  29. for (int i = 0; i < poker.size(); i++){
  30. //先添加底牌
  31. if (i >= poker.size() - 3){
  32. dipai.add(poker.get(i));
  33. }else if(i % 3 == 0){
  34. //i%3:这个好好想想--在剩余的51张牌中,有17个下标是可以将3整除的
  35. tmac.add(poker.get(i));
  36. }else if(i % 3 == 1){
  37. kobe.add(poker.get(i));
  38. }else{
  39. mine.add(poker.get(i));
  40. }
  41. }
  42. //4.看牌
  43. System.out.println(tmac);
  44. System.out.println(kobe);
  45. System.out.println(mine);
  46. System.out.println(dipai);
你的支持将鼓励作者继续创作

评论(0)

(无)