Java学习打卡第八天——[Collection终结之HashMap，Collections的简介和使用]

本文精炼介绍了Java集合框架中的List、Set、Map等核心概念与使用技巧，包括ArrayList与LinkedList的特点对比、HashSet的工作原理及HashMap的内部机制。此外，还提供了多个实际应用场景的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

今天已经是学习集合的第三天；
【1】第一天学习了Collection集合的List，ArrayList和LinkedList的常用方法和基础规则，
ArrayList特点总结：
1、ArrayList底层是数组，所以在获取元素时比较方便，属于List分支下的一种，允许集合中有相同的元素
2、LinkedList底层是链表，所有具有链表的特性在获取首元素，最有元素，插入元素，删除元素时比较方便，属于List分支下的一种
第一天学习集合的链接：
https://blog.csdn.net/weixin_44606952/article/details/122408384?spm=1001.2014.3001.5501
【2】第二天学习的是Collection集合的Set，TreeSet，和Generic(泛型)，
1、Set和HashSet底层都是Hash，HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合
2、HashSet 允许有 null 值。
3、HashSet 是无序的，即不会记录插入的顺序。
4、HashSet 不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。

https://blog.csdn.net/weixin_44606952/article/details/122413151?spm=1001.2014.3001.5501
【3】最后一天学习的是Collection集合的Map集合和Collections的使用

HashMap的特性简介

1、HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
2、HashMap 实现了== Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。==
3、HashMap 是无序的，即不会记录插入的顺序。
4、HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。
Hash的常用功能：
在这里插入图片描述
基本功能在创建Map集合之后直接掉方法使用就可以，这里主要介绍一下HashMap的遍历方法

HashMap的遍历方法一共有两种：
第一种键找值的方法遍历：
在这里插入图片描述
1、使用HashMap的keySet()方法获取所有的键（key），放到一个集合中
2、遍历键的集合，获取每一个key
3、根据key获取每一个value（值），使用的是Map的get（）
使用示例01：

 Set<String> set = map.keySet();
        for (String key : set){
            String value = map.get(key);
            System.out.println(key+","+value);
        }

遍历方法二：
直接看图片画黄色部分，解释的很清楚；
在这里插入图片描述
使用示例：

		Set<Map.Entry<String,String>> sm = map.entrySet();

        //增强for()得到每一个键值对，再利用getkey()和getvalue()得到键值对
        for (Map.Entry<String ,String> me : sm){
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+","+value);
        }

下面是几个使用集合的案例以供学习：
案例01：
在这里插入图片描述
Student类的完整代码：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试类：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        Map<String,Student> map = new HashMap<String,Student>();
        Student s1 = new Student("林青霞",22);
        Student s2 = new Student("张曼玉",23);
        Student s3 = new Student("王祖贤",24);
        Student s4 = new Student("朱茵",25);

        map.put("it001",s1);
        map.put("it002",s2);
        map.put("it003",s3);
        map.put("it004",s4);

        //遍历集合方法一//键值对对象找键和值
        //使用map.entrySet()方法得到键值对，然后利用get方法得到键和值
        Set<Map.Entry<String,Student>> mp = map.entrySet();

        for (Map.Entry<String,Student> me : mp){
            String id = me.getKey();
            Student s = me.getValue();
            System.out.println(id+","+s.getName()+","+s.getAge());
        }

        System.out.println("-----------");
        //遍历集合方法二//键找值
        //先使用Set集合得到所有键的集合在利用map的get方法得到所有的值
        Set<String> set = map.keySet();
        for (String s : set){
            Student stu = map.get(s);
            System.out.println(s+","+stu.getName()+","+stu.getAge());
        }

    }
}

综合案例02：
在这里插入图片描述

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {

        ArrayList<HashMap<String,String>> arr = new ArrayList<HashMap<String,String>>();

        HashMap<String,String> map = new HashMap<String,String>();
        map.put("黄蓉","郭靖");
        map.put("杨康","穆念慈");

        HashMap<String,String> map1 = new HashMap<String,String>();
        map1.put("杨过","小龙女");
        map1.put("令狐冲","任盈盈");

        HashMap<String,String> map2 = new HashMap<String,String>();
        map2.put("董永","七仙女");
        map2.put("林平之","岳灵珊");

        arr.add(map);
        arr.add(map1);
        arr.add(map2);

        //遍历集合
        //牵扯到集合嵌套集合使用双层循环依次实现每一层集合的遍历即可
        for (Map<String ,String> me : arr){
            Set<Map.Entry<String, String>> set = me.entrySet();
            for (Map.Entry<String, String> mp : set){
                String key = mp.getKey();
                String value = mp.getValue();
                System.out.println(key+","+value);
            }
        }
        System.out.println("----------");
        for (Map<String ,String> me : arr){
            Set<String> key = me.keySet();
            for (String keyy : key){
                String value = me.get(keyy);
                System.out.println(keyy+","+value);
            }
        }

    }
}

案例03：
在这里插入图片描述
案例提示：
关键部分在于把字符串正确添加到集合中去，方法是对每碰到一个字符就是用get方法获得对应的值（也就是出现次数），如果为空就把字符直接添加，如果不是就把值+1，然后重新添加，根据HashMap的特点会覆盖掉以前的键值对，另外，如果想让键值对变得有序创建集合的时候改用TreeMap即可

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

public class MapDemo {
    public static void main(String[] args) {
        //创建一个HashMap集合对象，键是Character值是Integer类型
        HashMap<Character,Integer> map = new HashMap<Character,Integer>();
        //如果想让集合变得有序可以使用TreeMap
//        TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();

        //输入一个字符串
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();

        //遍历字符串
        for (int i = 0; i < line.length(); i++){

            //用一个字符key来接受，使用get方法得到键为key对应的值的结果
            char key = line.charAt(i);
            Integer value = map.get(key);

            //如果值是null说明集合中没有存储该字符，不等于null就把值的数值加1，再次存储HashMap集合会自动覆盖以前的键值对
            if (value == null){
                map.put(key,1);
            }else {
                value++;
                map.put(key,value);
            }
        }

        //遍历键值对通过StringBuilder来取出集合里面的键值对并且按照要求得出结果字符串
        StringBuilder sb = new StringBuilder();
        //遍历集合使用键找值的方法
        Set<Character> keySet = map.keySet();
        for (Character key: keySet){
            Integer value = map.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String s = sb.toString();
        System.out.println(s);
    }
}

Collections的简介和应用

此类仅包含对集合进行操作或返回集合的静态方法。它包含对集合进行操作的多态算法，“包装器”，它返回由指定集合支持的新集合，以及其他一些可能性和结束。

Collections常用三种方法：

  		 //static <T extends Comparable<? super T>>
        //void sort(List<T> list) 根据其元素的natural ordering ，将指定列表按升序排序。
        Collections.sort(list);

        //static void reverse(List<?> list) 反转指定列表中元素的顺序。
        Collections.reverse(list);

        //static void shuffle(List<?> list) 使用默认的随机源随机置换指定的列表。  (和洗牌一样的操作)
        Collections.shuffle(list);

使用案例：
模拟斗地主：
在这里插入图片描述
主要使用了Collections的shuffle()方法，完成洗牌动作，把牌盒，每一个玩家的牌都看是一个ArrayList 集合，直接集合里面添加元素就完成了发牌动作；思路和代码中给出了详细的注释，可以试着打一遍哦

import java.util.ArrayList;
import java.util.Collections;

public class CollectionsDemo {
    public static void main(String[] args) {

        //创建一个集合来装牌
        ArrayList<String> array = new ArrayList<String>();
        /*
            牌的颜色一共有4种
            ♥
            ♣
            ♠
            ♦
            牌的大小一共是13中
            2，3，4，5，6，7，8，9，10,J，Q，K,A
            大王小王
        */
        //创建两个字符串数组把牌色和大小对应起来
        String[] colors = {"♥", "♣", "♠", "♦"};
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};

        //装牌
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color + number);
            }
        }
        array.add("大王");
        array.add("小王");

        //调用Collections的shuffle方法将牌打乱
        Collections.shuffle(array);

        //创建四个集合，三个集合代表三个玩家，剩下一个集合标底牌
        ArrayList<String> array1 = new ArrayList<String>();
        ArrayList<String> array2 = new ArrayList<String>();
        ArrayList<String> array3 = new ArrayList<String>();
        ArrayList<String> array4 = new ArrayList<String>();
        //开始发牌
        //如果当前第i张牌减去（牌的数量减去3）大于等于零说明剩下的三张是底牌
        //i%3表示顺序发牌
        for (int i = 0; i < array.size(); i++) {
            String s = array.get(i);
            if (i - (array.size() - 3) >= 0) {
                array4.add(s);
            } else if (i % 3 == 0) {
                array1.add(s);
            } else if (i % 3 == 1) {
                array2.add(s);
            } else {
                array3.add(s);
            }
        }


        //遍历四个集合查看发牌
        lookpoke("刘德华",array1);
        lookpoke("郭富城",array2);
        lookpoke("黎明",array3);
        lookpoke("底牌",array4);
        /*System.out.println(array1);
        System.out.println(array2);
        System.out.println(array3);
        System.out.println(array4);*/
    }
    public static void lookpoke(String name,ArrayList<String> arrayList){
        System.out.print(name+"的牌是：");
        for (String poker : arrayList){
            System.out.print(poker+",");
        }
        System.out.println();
    }
}