JAVASE(15)MAP集合

最新推荐文章于 2022-11-16 13:03:39 发布

GEX0o0

最新推荐文章于 2022-11-16 13:03:39 发布

阅读量125

点赞数

分类专栏：后端学习:JAVASE

本文链接：https://blog.csdn.net/gexin0517/article/details/96644910

版权

后端学习:JAVASE 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

KeyWords:

Map集合
- HashMap
- LinkedHashMap
- TreeMap
集合嵌套
- HashMap嵌套HashMap
- HashMap嵌套ArrayList
- ArrayList嵌套HashMap
HashMap和Hashtable的区别
Collectins集合
集合框架案例：模拟斗地主洗牌和发牌

Map集合

Map的继承关系：

在这里插入图片描述
举例：

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;
    }
}
//创建一个学生类
//根据学号回获取学生的信息
public class Demo {
    public static void main(String[] args) {
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("s001",new Student("zhangsan",20));
        hashMap.put("s002",new Student("lisi",23));
        hashMap.put("s003",new Student("wangwu",25));
        Student student = hashMap.get("s001");
        System.out.println(student.getName().concat("==") + student.getAge());
    }
}

Map接口概述：
将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。

Map接口和Collection接口的不同

Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

下面为两个集合的结构图：
在这里插入图片描述

Map集合的功能

在这里插入图片描述

Map集合的遍历之键找值：

思路：

首先获取所有键的集合
遍历键的集合，并根据Map的获取的方法，
根据遍历的键查找值

案例演示：

public class Demo1 {
    //利用键集合遍历Hashmap
    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"qqq");
        hashMap.put(2,"www");
        hashMap.put(3,"eee");
        Set<Integer> keySet = hashMap.keySet();
        for (Integer key : keySet) {
            System.out.println(hashMap.get(key));
        }
    }
}

Map集合的遍历之键值对对象找键和值

思路：

获取所有的键值对的集合
遍历键值对的集合，获取每一个键值对对象
根据键值对对象查找键或者值

案例演示：

public class Demo1 {
    //利用键值对对象集合遍历Hashmap
    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();
        hashMap.put(1,"qqq");
        hashMap.put(2,"www");
        hashMap.put(3,"eee");
        Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey() + "==" + entry.getValue());
        }
    }
}

HashMap

HashMap集合键是Stirng值是String的案例

public class Demo2 {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("1","zhangsan");
        hashMap.put("2","lisi");
        hashMap.put("3","wangwu");
        hashMap.put(null,null);
    }
}

注意：允许插入null键 null值

HashMap集合键是Student值是String的案例

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;
    }
}
public class Demo {
    public static void main(String[] args) {
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("s001",new Student("zhangsan",20));
        hashMap.put("s002",new Student("lisi",23));
        hashMap.put("s003",new Student("wangwu",25));
        Set<String> keySet = hashMap.keySet();
        Student student = hashMap.get("s001");
        System.out.println(student.getName().concat("==") + student.getAge());
    }
}

HashMap集合键是Student值是String的案例

注意重写hashCode方法和 equals 方法

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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
//创建一个学生类
public class Demo3 {
    public static void main(String[] args) {
        HashMap<Student, String> hashMap = new HashMap<>();
        hashMap.put(new Student("zhangsan",20),"zhangsan");
        hashMap.put(new Student("lisi",22),"lisi");
        hashMap.put(new Student("wangwu",24),"wangwu");
        String lisi = hashMap.get(new Student("lisi", 22));
        System.out.println(lisi);
    }
}

LinkedHashMap

LinkedHashMap的概述:Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。

LinkedHashMap的特点：底层的数据结构是链表和哈希表，元素有序并且唯一

元素的有序性由链表数据结构保证
唯一性由哈希表数据结构保证,Map集合的数据结构只和键有关

案例演示:LinkedHashMap的特点

public class Demo4 {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put(1,"zhangsan");
        linkedHashMap.put(1,"zhangsan");
        linkedHashMap.put(1,"zhangsan");
        linkedHashMap.put(2,"lisi");
        linkedHashMap.put(2,"lisi");
        linkedHashMap.put(2,"lisi");
        linkedHashMap.put(3,"wangwu");
        linkedHashMap.put(2,"lisi");
        Set<Integer> keySet = linkedHashMap.keySet();
        for (Integer key : keySet) {
            System.out.println(key+"=="+linkedHashMap.get(key));
        }
    }
}
------------------
1==zhangsan
2==lisi
3==wangwu

TreeMap集合

TreeMap集合键是String值是String的案例

TreeMap中不允许出现null值

键的数据结构是红黑树,可保证键的排序和唯一性
在这里插入图片描述

排序分为自然排序和比较器排序线程是不安全的效率比较高

案例演示:TreeMap集合键是Integer值是String的案例

public class Demo5 {
    //自然排序，因为String方法实现Compareible接口
    public static void main(String[] args) {
        TreeMap<String , String> treeMap = new TreeMap<>();
        treeMap.put("1","qqq");
        treeMap.put("1","qqq");
        treeMap.put("2","qqq");
        treeMap.put("2","www");
        treeMap.put("2","www");
        treeMap.put("2","www");
        treeMap.put("3","ttt");
        treeMap.put("3","ttt");
        Set<String> keySet = treeMap.keySet();
        for (String key : keySet) {
            System.out.println(key.concat("==").concat(treeMap.get(key)));
        }
    }
}
1==qqq
2==www
3==ttt

TreeMap集合键是Student值是String的案例

使用比较器排序

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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class Demo6 {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        treeMap.put(new Student("zhngsan",20),"zahngsan");
        treeMap.put(new Student("lisi",22),"lisi");
        treeMap.put(new Student("wangwu",24),"wangwu");
        treeMap.put(new Student("zhngsan",20),"zahngsan");
        Set<Student> keySet = treeMap.keySet();
        for (Student key : keySet) {
            System.out.println(key.getAge()+"=="+key.getName()+treeMap.get(key));
        }
    }
}

自然排序

public class Student implements Comparable {
    private String name;
    private int age;
    @Override
    //继承了Comparable的接口
    //重写了里面额方法
    public int compareTo(Object o) {
        Student compare= (Student) o;
        int num = age - compare.age;
        int num2=num==0?name.compareTo(compare.name):num;
        return num2;
    }
    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;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class Demo7 {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("zhngsan",20),"zahngsan");
        treeMap.put(new Student("lisi",22),"lisi");
        treeMap.put(new Student("wangwu",24),"wangwu");
        treeMap.put(new Student("zhngsan",20),"zahngsan");
        Set<Student> keySet = treeMap.keySet();
        for (Student key : keySet) {
            System.out.println(key.getAge()+"=="+key.getName()+treeMap.get(key));
        }
    }
}
20==zhngsanzahngsan
22==lisilisi
24==wangwuwangwu

统计字符串中每个字符出现的次数

需求：统计字符串中每个字符出现的次数
“aababcabcdabcde”,获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public class Demo8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String line = sc.nextLine();
        TreeMap<Character, Integer> treeMap = new TreeMap<>();
        //创建一个键为字符 值为整型的一个一个集合
        for (int i = 0; i < line.length()-1; i++) {
            char ch = line.charAt(i);
            //获取字符串中的单个字符
            //对单个字符进行判断
            if (!treeMap.containsKey(ch)){
                //判断单个字符是否出现在键的集合中
                //如果不存在，则说明只存在一个字符，经单个字符和1加到集合中
                treeMap.put(ch,1);
            }else {
                //如果不止一个字符，则让找到获取他的值，并且自增
                //假如，获取的的一个数为值为1
                Integer num = treeMap.get(ch);
                num++;
                //则找到相同的字符的时候的值自己增加一次
                //再将增加后的值放到集合中，修改原来的num值
                //找到相同的字符就增加一次
                treeMap.put(ch,num);
            }
        }
        Set<Character> keySet = treeMap.keySet();
        StringBuffer strb = new StringBuffer();
        for (Character key : keySet) {
            strb.append(key).append("( ").append(treeMap.get(key)).append(" )  ");
        }
        System.out.println(strb);
    }
}

集合嵌套

集合嵌套之HashMap嵌套HashMap

需求：

基础班
张三 20
李四 22
就业班
王五 21
赵六 23

代码：

public class Demo7 {
    public static void main(String[] args) {
        HashMap<String, Integer> jchashMap = new HashMap<>();
        jchashMap.put("张三", 20);
        jchashMap.put("李四", 22);
        HashMap<String, Integer> jyhashMap = new HashMap<>();
        jyhashMap.put("张三", 20);
        jyhashMap.put("李四", 22);
        HashMap<String, HashMap<String, Integer>> mapHashMap = new HashMap<>();
        mapHashMap.put("基础班", jchashMap);
        mapHashMap.put("就业班", jyhashMap);
        Set<String> keySet = mapHashMap.keySet();
        for (String s : keySet) {
            System.out.println(s);
            HashMap<String, Integer> integerHashMap = mapHashMap.get(s);
            Set<String> keySet1 = integerHashMap.keySet();
            for (String s1 : keySet1) {
                System.out.println(s1 + "   " + integerHashMap.get(s1));
            }
        }
            /*Set<Map.Entry<String, HashMap<String, Integer>>> entries = mapHashMap.entrySet();
            for (Map.Entry<String, HashMap<String, Integer>> entry : entries) {
            System.out.println(entry.getKey());
                HashMap<String, Integer> hashMap = entry.getValue();
                Set<Map.Entry<String, Integer>> entries1 = hashMap.entrySet();
                for (Map.Entry<String, Integer> integerEntry : entries1) {
                System.out.println(integerEntry.getKey() + "  " + integerEntry.getValue());
	            }
	        }
	        */
    }
}

集合嵌套之HashMap嵌套ArrayList

需求：

三国演义
吕布
周瑜
笑傲江湖
令狐冲
林平之
神雕侠侣
郭靖
杨过

代码：

public class Demo1 {
    public static void main(String[] args) {
        ArrayList sglist = new ArrayList();
        sglist.add("吕布");
        sglist.add("周瑜");
        ArrayList xalist = new ArrayList();
        xalist.add("令狐冲");
        xalist.add("林平之");
        ArrayList sdlist = new ArrayList();
        sdlist.add("郭靖");
        sdlist.add("杨过");
        HashMap<String, ArrayList> hashMap = new HashMap<>();
        hashMap.put("三国演义", sglist);
        hashMap.put("笑傲江湖", xalist);
        hashMap.put("神雕侠侣", sdlist);
        Set<String> keySet = hashMap.keySet();
        for (String s : keySet) {
            System.out.println(s);
            ArrayList arrayList = hashMap.get(s);
            for (Object o : arrayList) {
                System.out.println(o);
            }
        }
    }
}

集合嵌套之ArrayList嵌套HashMap

需求：

周瑜—小乔
吕布—貂蝉

郭靖—黄蓉
杨过—小龙女

令狐冲—任盈盈
林平之—岳灵珊

代码：

public class Demo10 {
    public static void main(String[] args) {
        HashMap<String, String> sghashMap = new HashMap<>();
        sghashMap.put("周瑜", "小乔");
        sghashMap.put("吕布", "貂蝉");
        HashMap<String, String> sdhashMap = new HashMap<>();
        sdhashMap.put("郭靖", "黄蓉");
        sdhashMap.put("杨过", "小龙女");
        HashMap<String, String> xahashMap = new HashMap<>();
        xahashMap.put("令狐冲", "任盈盈");
        xahashMap.put("林平之", "岳灵珊");
        ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
        arrayList.add(sghashMap);
        arrayList.add(sdhashMap);
        arrayList.add(xahashMap);
        for (HashMap<String, String> hashMap : arrayList) {
            Set<String> keySet = hashMap.keySet();
            System.out.println();
            for (String s : keySet) {
                System.out.println(s + "---" + hashMap.get(s));
            }
        }
    }
}

HashMap和Hashtable的区别

HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键

Collections工具类

在这里插入图片描述

模拟斗地主洗牌和发牌

代码如下:

public class Demo1 {
    public static void main(String[] args) {
        String[] color = {"♠", "♥", "♦", "♣"};
        String[] num = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        ArrayList<Integer> indexslist = new ArrayList<>();
        //1.定义一个集合将索引值装起来
        Integer index = 0;
        HashMap<Integer, String> hashMap = new HashMap<>();
        //2.定义一个以索引值集合为键，以花色和数字组合的字符串为值的双链表
        for (String s : num) {
            for (String s1 : color) {
                hashMap.put(index, s.concat(s1));
                indexslist.add(index);
                //在双链表里每放一次在索引值的集合中也加如一次索引值
                index++;
                //没加一次索引值就增加一次
            }
        }
        
        hashMap.put(index, "大王");
        //双链表中加入大小王
        indexslist.add(index);
        //双链表中每增加一组键值对，就在索引值集合中增加一个索引值
        index++;
        //索引值增加一次，加入下次还要加如索引值，可以直接加如到索引值的集合中
        hashMap.put(index, "小王");
        indexslist.add(index);

        //洗牌
        Collections.shuffle(indexslist);
        Collections.shuffle(indexslist);
        Collections.shuffle(indexslist);
        //此时，索引值集合中的值是乱的
        
        
        //发牌
        //定义三个玩家集合和一个底牌的集合
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        TreeSet<Integer> 底牌 = new TreeSet<>();
        for (int i = 0; i < indexslist.size(); i++) {
            if (i>=indexslist.size()-3){
                底牌.add(indexslist.get(i));
            //将底牌的最后三张牌放置在底牌中
            }else if (i%3==0){
                player1.add(indexslist.get(i));
            }else if (i%3==1){
                player2.add(indexslist.get(i));
            }else if (i%3==2){
                player3.add(indexslist.get(i));
            }
            //将索引值集合中的值的索引值按要求放在TreeSet集合中
            //根据TreeSet的原理，有序且唯一，将放进来的索引值进行排序
            //判断整处3后取余数，目的是为了将牌组平均分发成3份
        }

        //看牌
        Lookpoker("player1",player1,hashMap);
        Lookpoker("player2",player2,hashMap);
        Lookpoker("player3",player3,hashMap);
        Lookpoker("底牌",底牌,hashMap);
    }

    private static void Lookpoker(String name, TreeSet<Integer> player, HashMap<Integer, String> poker) {
        System.out.println(name);
        for (Integer integer : player) {
            System.out.print(poker.get(integer)+"\t");
        }
        //根据索引集合中的值作为键提取双链表中的值
        System.out.println();
    }
}