Java Collection体系特点 Set集合体系 Map集合体系

程序员希西子

已于 2023-09-16 17:09:24 修改

阅读量135

点赞数

分类专栏： Java面向对象进阶栏文章标签： java java-ee

于 2023-05-05 19:58:04 首次发布

本文链接：https://blog.csdn.net/wangjh11234/article/details/130457811

版权

Java面向对象进阶栏专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一.set系列集合

1.set系列集系概述

package com.wjh_Set_Map.d1_set;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class SetDemo1 {
    public static void main(String[] args) {
        //看看set系列集合的特点:    
        //      1.HashSet -> 无序,不重复,无索引       
        //        (1)LinkedHashSet -> 有序,不重复,无索引
        //      2.TreeSet -> 排序,不重复,无索引
        Set<String> sets = new HashSet<>();     //多态;经典写法
        sets.add("MySql");
        sets.add("Java");
        sets.add("Java");
        sets.add("MyBatis");
        sets.add("HTML");
        sets.add("SpringBoot");
        sets.add("HTML");
        sets.add("SpringBoot");
        System.out.println(sets);
        //[Java, MySql, MyBatis, HTML, SpringBoot]
        //无序,不重复,无索引
        
        
    }
}

[Java, MySql, MyBatis, HTML, SpringBoot]

进程已结束，退出代码为 0

2.HashSet元素无序的底层原理:哈希表

package com.wjh_Set_Map.d1_set;

public class SetDemo2 {
    public static void main(String[] args) {
        //目标:学会获取对象的哈希值,并确认一下
        String name = "iKun";
        System.out.println(name.hashCode());    //3203867
        System.out.println(name.hashCode());    //3203867
        String name1 = "iKuu";
        System.out.println(name1.hashCode());   //3203874
        System.out.println(name1.hashCode());   //3203874
        
    }
}

3203867
3203867

3203874
3203874

进程已结束，退出代码为 0

3.HashSet元素去重复的底层原理

Student学生类:

package com.wjh_Set_Map.d1_set;

import java.util.Objects;

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

    public Student() {
    }

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

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    /**
     * 只要两个对象内容一样,结果一定是true
     * @param o
     * @return
     */
    @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 && sex == student.sex && Objects.equals(name, student.name);
    }

    /*
    s1 = new Student("小明", 23,'男');
    s2 = new Student("小红", 18,'女');
    s3 = new Student("小琳", 22,'女');
    s4 = new Student("小琳", 22,'女');
     */

    /**
     *
     * @return
     */
    @Override
    public int hashCode() {
        return Objects.hash(name, age, sex);
    }


    /**
     *
     * @return
    //重写toString方法 : 输入toS 快捷生成
     */
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

测试类:

package com.wjh_Set_Map.d1_set;
/*
    目标:让Set集合把重复内容的对象去掉一个(去重复)

 */

import java.util.HashSet;
import java.util.Set;

public class SetDemo3 {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 23,'男');
        Student s2 = new Student("小红", 18,'女');
        Student s3 = new Student("小琳", 22,'女');
        Student s4 = new Student("小琳", 22,'女');
        System.out.println(s1.hashCode());  //727252094
        System.out.println(s2.hashCode());  //733291443
        System.out.println(s3.hashCode());  //730724736  一样
        System.out.println(s4.hashCode());  //730724736  一样

        //Set集合去重复原因:先判断哈希值 再判断equals
        Set<Student> sets = new HashSet<>();
        sets.add(s1);
        sets.add(s2);
        sets.add(s3);
        sets.add(s4);

        System.out.println(sets);
       // [Student{name='小红', age=18, sex=女}, Student{name='小琳', age=22, sex=女}, Student{name='小明', age=23, sex=男}, Student{name='小琳', age=22, sex=女}]

    }
}

727252094
733291443
730724736
730724736
[Student{name='小明', age=23, sex=男}, Student{name='小红', age=18, sex=女}, Student{name='小琳', age=22, sex=女}]

进程已结束，退出代码为 0

4.实现类:LinkedHashSet

package com.wjh_Set_Map.d1_set;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

public class SetDemo4 {
    public static void main(String[] args) {
        //看看set系列集合的特点:
        //      1.HashSet -> 无序,不重复,无索引
        //        (1)LinkedHashSet -> 有序,不重复,无索引
        //      2.TreeSet -> 排序,不重复,无索引
        Set<String> sets = new LinkedHashSet<>();     //多态;经典写法
        sets.add("MySql");
        sets.add("Java");
        sets.add("Java");
        sets.add("MyBatis");
        sets.add("HTML");
        sets.add("SpringBoot");
        sets.add("HTML");
        sets.add("SpringBoot");
        System.out.println(sets);
        //[Java, MySql, MyBatis, HTML, SpringBoot]
        //无序,不重复,无索引


    }
}

[MySql, Java, MyBatis, HTML, SpringBoot]

进程已结束，退出代码为 0

5.实现类:TreeSet

Apple类:

package com.wjh_Set_Map.d1_set;
/*
    由于TreeSet中自定义数据类型不能比较
    所以要在该类中 implements Comparable<类名称>
    之后 Alt + Enter 重写方法
 */
public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private Double weight;
    private int much;

    public Apple() {
    }

    public Apple(String name, String color, Double weight, int much) {
        this.name = name;
        this.color = color;
        this.weight = weight;
        this.much = much;
    }

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }

    public int getMuch() {
        return much;
    }

    public void setMuch(int much) {
        this.much = much;
    }



    // toString 重写方法
    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", weight=" + weight +
                ", much=" + much +
                '}';
    }

    /**
     * 方式一:类自定义比较规则
     * o1.compareTo(o2)
     * @param o
     * @return
     */
    @Override
    public int compareTo(Apple o) {
        //按照重量进行比较
        return (int) (this.weight - o.weight); //去重量重复的元素
        //return (int) (this.weight - o.weight) >= 0 ? 1 : -1;
        //保留重量重复的元素
    }
}

测试类:

package com.wjh_Set_Map.d1_set;
/*
   目标:观察TreeSet对于有值特性的数据如何排序
        学会自定义类型的对象进行指定规则排序
 */

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

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

        //创建一个TreeSet多态对象,特点:可排序,去重复,无索引
        Set<Integer> treeSet = new TreeSet<>();
        treeSet.add(23);
        treeSet.add(24);
        treeSet.add(8);
        treeSet.add(12);
        System.out.println(treeSet);
        //[8, 12, 23, 24] -> 整数类型 按照升序排列

        Set<String> treeSet1 = new TreeSet<>();
        treeSet1.add("Java");
        treeSet1.add("HTML");
        treeSet1.add("Home");
        treeSet1.add("Apple");
        treeSet1.add("APods");
        treeSet1.add("Adidas");
        treeSet1.add("Python");
        treeSet1.add("UI");
        treeSet1.add("Zip");
        treeSet1.add("UI");
        System.out.println(treeSet1);
        //[APods,Adidas, Apple, HTML, Home, Java, Python, UI, Zip]
        // -> 字符串类型 按照首字母顺序排列(大写有优先权)

        System.out.println("-------试试自定义类型排序--------");

        //方式一:定制比较规则
        //Set<Apple> apples = new TreeSet<>();
        
        //方式二:集合自带比较器对象进行比较规则定制
        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                //return (int)(o1.getWeight() - o2.getWeight());  //按重量升序
                return (int)(o2.getWeight() - o1.getWeight());    //按重量降序
                
                //浮点型建议直接使用(Double.compare(o2, o1)
                //return Double.compare(o2.getPrice() , o1.getPrice());
            }
        });
        
        apples.add(new Apple("红富士", "红色", 6.5, 5));
        apples.add(new Apple("蛇果", "酒红色", 10.2, 2));
        apples.add(new Apple("青苹果", "红色", 15.9, 9));
        apples.add(new Apple("苹果14ProMax暗夜紫1TB", "土豪金", 0.65, 1));
        System.out.println(apples);

        for (Apple a : apples) {
            System.out.println("名称:" + a.getName());
            System.out.println("颜色:" + a.getColor());
            System.out.println("重量:" + a.getWeight() + "kg");
            System.out.println("个数:" + a.getMuch());
            System.out.println();
        }

        
    }
}

[8, 12, 23, 24]
[APods, Adidas, Apple, HTML, Home, Java, Python, UI, Zip]
-------试试自定义类型排序--------
[Apple{name='苹果14ProMax暗夜紫1TB', color='土豪金', weight=0.65, much=1}, Apple{name='红富士', color='红色', weight=6.5, much=5}, Apple{name='蛇果', color='酒红色', weight=10.2, much=2}, Apple{name='青苹果', color='红色', weight=15.9, much=9}]
名称:苹果14ProMax暗夜紫1TB
颜色:土豪金
重量:0.65kg
个数:1

名称:红富士
颜色:红色
重量:6.5kg
个数:5

名称:蛇果
颜色:酒红色
重量:10.2kg
个数:2

名称:青苹果
颜色:红色
重量:15.9kg
个数:9

进程已结束，退出代码为 0

TreeSet自定义比较规则中建议使用: -> 集合自带比较器对象进行比较规则定制,重写比较规则

（两个比较器都有的话默认也是使用的集合自带的比较器）

(集合自带比较器对象进行比较规则定制,重写比较规则) 代码简化:

//代码简化:
Set<Apple> apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getMuch() , o1.getMuch())); 
//浮点型用Double.compare(o1, o2)

PS: (自己写的,代码还待优化,哈哈哈)

Student类:

package com.wjh_Set_Map.d11_Student_TreeSet;

//1.定义学生类
public class Student {
    private String name;
    private Double chinese;
    private Double math;
    private Double english;
    private Double score;

    public Student() {

    }

    public Student(String name, Double chinese, Double math, Double english, Double score) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public Double getChinese() {
        return chinese;
    }

    public void setChinese(Double chinese) {
        this.chinese = chinese;
    }

    public Double getMath() {
        return math;
    }

    public void setMath(Double math) {
        this.math = math;
    }

    public Double getEnglish() {
        return english;
    }

    public void setEnglish(Double english) {
        this.english = english;
    }

    public Double getScore() {
        return score;
    }

    public void setScore(Double score) {
        this.score = score;
    }

    // toString 重写方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", chinese=" + chinese +
                ", math=" + math +
                ", english=" + english +
                ", score=" + score +
                '}';
    }
}

测试类:

package com.wjh_Set_Map.d11_Student_TreeSet;

import java.util.Comparator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

/*
    TreeSet集合进行对象排序
需求：键盘录入3个学生信息(姓名,语文成绩,数学成绩,英语成绩)
    按照总分从高到低输出到控制台
分析
定义学生类
创建TreeSet集合对象，通过比较器排序进行排序
创建学生对象
把学生对象添加到集合
遍历集合

 */

//Set<Apple> apples = new TreeSet<>((o1, o2) -> Double.compare(o2.getMuch() , o1.getMuch()));
浮点型用Double.compare(o1, o2)
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //2.创建TreeSet集合对象，通过比较器排序进行排序
        Set<Student> stu = new TreeSet<>(((o1, o2) -> Double.compare(o2.getScore(), o1.getScore())));

        Student s = new Student();

        System.out.println("-----欢迎使用学生成绩系统-----");
        for (int i = 1; i <= 3; i++) {
            System.out.print("请输入学生"+ i +"姓名:");
            String name = sc.next();

            System.out.print("请输入学生"+ i +"语文成绩:");
            double chinese = sc.nextDouble();

            System.out.print("请输入学生"+ i +"数学成绩:");
            double math = sc.nextDouble();

            System.out.print("请输入学生"+ i +"英语成绩:");
            double english = sc.nextDouble();

            double scores = chinese + math + english;
            s.setScore(scores);
            stu.add(new Student(name,chinese,math,english,scores));
        }

        System.out.println("-----学生信息如下-----");
        for (Student ss : stu) {
            System.out.println("姓名:" + ss.getName() +"\t\t"+ "语文:" + ss.getChinese() + "\t\t"+ "数学:" + ss.getMath() + "\t\t"+ "英语" + ss.getEnglish() + "\t\t" + "总分" + ss.getScore());
        }

    }


}

-----欢迎使用学生成绩系统-----
请输入学生1姓名:小明
请输入学生1语文成绩:66
请输入学生1数学成绩:78.5
请输入学生1英语成绩:80
请输入学生2姓名:小黑
请输入学生2语文成绩:56
请输入学生2数学成绩:59.5
请输入学生2英语成绩:30
请输入学生3姓名:小林
请输入学生3语文成绩:98
请输入学生3数学成绩:99
请输入学生3英语成绩:99.5
-----学生信息如下-----
姓名:小林       语文:98.0       数学:99.0       英语99.5       总分296.5
姓名:小明       语文:66.0       数学:78.5       英语80.0       总分224.5
姓名:小黑       语文:56.0       数学:59.5       英语30.0       总分145.5

进程已结束，退出代码为 0

二.Collection体系的特点(重点)

适用场景:

(1) ArrayList: 增删相对慢(忽略不计)

(2)LinkedList: 栈,队列(如排队系统)

(3)HashSet:

(4)LinkedHashSet:

(5)TreeSet:

三.补充知识:可变参数

package com.wjh_Set_Map.d2_params;

import java.lang.reflect.Array;
import java.util.Arrays;

public class MethodDemo {
    public static void main(String[] args) {
        sum();  //1.不传参数
        sum(10);  //2.传一个参数
        sum(10,20,30);  //3.传多个参数
        sum(new int[]{10, 20, 30, 40, 50});  //4.传输数组
    }

    /**
     * (int...nums)作用:可以传一个参数,多个参数,一个数组
     * @param nums
     */
    public static void sum(int...nums){
        //注意:可变参数在方法内部就是一个数组,nums
        System.out.println("元素个数:" + nums.length);
        System.out.println("元素内容:" + Arrays.toString(nums));
        System.out.println();

    }
}

元素个数:0
元素内容:[]

元素个数:1
元素内容:[10]

元素个数:3
元素内容:[10, 20, 30]

元素个数:5
元素内容:[10, 20, 30, 40, 50]

进程已结束，退出代码为 0

* 注意:一个形参列表只能有一个可变参数,可变参数必须放在形参列表后面

四.补充知识:集合工具类Collection

五.Collection体系的综合案例

package com.wjh_Set_Map.d22_doudizhu;
/*
需求：在启动游戏房间的时候，应该提前准备好54张牌，完成洗牌、发牌、牌排序、逻辑。

分析：
    1：当系统启动的同时需要准备好数据的时候，就可以用静态代码块了。
    2：洗牌就是打乱牌的顺序。
    3：定义三个玩家、依次发出51张牌
    4：给玩家的牌进行排序(拓展)
    5：输出每个玩家的牌数据。

功能:
    1.做牌
    2.洗牌
    3.定义3个玩家
    4.发牌
    5.排序(拓展,了解,作业)
    6.看牌
 */

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

public class Test {
    /**
     * 1.定义一个静态的集合存储54个对象
     */
    public static List<Card> allCard = new ArrayList<>();
    /*
    2.做牌:定义静态代码块进行排数据
     */
    static {
        //3.定义点数:个数确定,类型确定,使用数组
        String[] size = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //4.定义花色:个数确定,类型确定,使用数组
        String[] color = {"♠", "♦", "♣", "♥"};
        //5.组合点数 和 花色
        int index = 0; //记录牌的大小
        for (String s : size) {
            index++;    //index  + 1
            for (String c : color) {
                //6.封装成一个牌对象
                Card card = new Card(s,c,index);
                //7.存入到集合容器中去
                allCard.add(card);
            }
        }
        //8.大小王没有花色
        Card c1 = new Card("","D",14);
        Card c2 = new Card("","X",15);
        //9.将大小王添加到容器中去
        Collections.addAll(allCard,c1,c2);
        System.out.println("新牌:" + allCard);

    }


    public static void main(String[] args) {

        Collections.shuffle(allCard);
        System.out.println("牌洗好了:" + allCard);
        System.out.println("共有" + allCard.size() + "张牌");

        //10.定义三个玩家,开始发牌(每个玩家的牌也是一个集合容器)
        List<Card> iKUN = new ArrayList<>();
        List<Card> cTRL = new ArrayList<>();
        List<Card> xHZ = new ArrayList<>();

        //11.开始发牌(从集合中发出51张牌,剩余三张作为底牌)
        for (int i = 0; i < allCard.size() - 3; i++) {
            //先拿到当前牌对象
            Card c = allCard.get(i);
            if(i % 3 == 0){
                iKUN.add(c);
            }else if(i % 3 == 1){
                cTRL.add(c);
            }else if(i % 3 == 2){
                xHZ.add(c);
            }

        }

        //难点:新API subList(size1,size2):包前不包后
        //12.拿到最后3张底牌(把最后三张牌截取成一个子集合)
        List<Card> lastThreeCards = allCard.subList(allCard.size() - 3, allCard.size());

        //13.给玩家排序(从大到小)
        //Collections.sort(apples,(o1,o2) -> Double.compare(o1.getWeight(), o2.getWeight()));
        descCards(iKUN);
        descCards(cTRL);
        descCards(xHZ);

        //14.输出玩家的牌
        System.out.println(lastThreeCards);
        System.out.println("iKUN有"+iKUN.size() + "张:" + iKUN);
        System.out.println("cTRL有"+cTRL.size() +  "张:"   + cTRL);
        System.out.println("xHZz有" +xHZ.size() +  "张:"   + xHZ);


    }

    /**
     * 给玩家的牌排序
     * @param cards
     */
    public static void descCards(List<Card> cards){
        Collections.sort(cards,((o2, o1) -> Double.compare(o1.getIndex(),o2.getIndex())));
    }
}

新牌:[3♠, 3♦, 3♣, 3♥, 4♠, 4♦, 4♣, 4♥, 5♠, 5♦, 5♣, 5♥, 6♠, 6♦, 6♣, 6♥, 7♠, 7♦, 7♣, 7♥, 8♠, 8♦, 8♣, 8♥, 9♠, 9♦, 9♣, 9♥, 10♠, 10♦, 10♣, 10♥, J♠, J♦, J♣, J♥, Q♠, Q♦, Q♣, Q♥, K♠, K♦, K♣, K♥, A♠, A♦, A♣, A♥, 2♠, 2♦, 2♣, 2♥, D, X]
牌洗好了:[Q♣, J♠, A♣, K♥, 10♦, Q♥, 8♣, 10♣, 5♦, X, 3♥, 3♣, 9♣, 6♣, 9♠, 7♠, A♦, 10♠, 5♥, 2♠, 6♥, A♠, 5♠, 2♥, Q♦, J♣, 9♥, D, 3♠, 6♠, 2♦, J♥, 5♣, 2♣, Q♠, 10♥, 8♠, K♦, 4♥, 4♠, 7♣, 9♦, 6♦, 4♦, 7♦, 4♣, J♦, 3♦, 8♥, 8♦, K♠, K♣, A♥, 7♥]
共有54张牌
[K♣, A♥, 7♥]
iKUN有17张:[X, D, 2♦, 2♣, A♠, K♥, Q♣, Q♦, 9♣, 8♣, 8♠, 8♥, 7♠, 6♦, 5♥, 4♠, 4♣]
cTRL有17张:[2♠, A♦, K♦, Q♠, J♠, J♣, J♥, J♦, 10♦, 10♣, 8♦, 7♣, 6♣, 5♠, 4♦, 3♥, 3♠]
xHZz有17张:[2♥, A♣, K♠, Q♥, 10♠, 10♥, 9♠, 9♥, 9♦, 7♦, 6♥, 6♠, 5♦, 5♣, 4♥, 3♣, 3♦]

进程已结束，退出代码为 0

六.Map集合体系

1.Map集合的概述

2.Map集合体系特点

package com.wjh_Set_Map.d5_map;
/*
    认识Map体系的特点:
        无序,不重复,无索引,值不做要求
 */

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

public class MapDemo {
    public static void main(String[] args) {
        //1.创建一个Map集合对象
        Map<String, Integer> maps = new HashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",10);
        maps.put("可乐",15);
        maps.put("矿泉水",50);
        maps.put(null,null);
        System.out.println(maps);
    }
}

{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}

进程已结束，退出代码为 0

3.Map集合常用API

package com.wjh_Set_Map.d6_map_api;

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

public class MapDemo {
    public static void main(String[] args) {
        //1.添加元素:无序,不重复,无索引.
        Map<String, Integer> maps = new HashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",100);
        maps.put("矿泉水",50);
        maps.put("咖啡",5);
        maps.put("纯牛奶",10); //Map集合后面重复的键对应的元素会覆盖前面重复的整个元素
        maps.put("可乐",15);
        maps.put(null,null);
        System.out.println(maps);
        //{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}

        //2.清空集合
//        maps.clear();
//        System.out.println(maps); //{}
//
//        //3.判断集合是否为空,为空返回true,不为空返回false
//        System.out.println(maps.isEmpty());   //true

        //4.根据键获取对应值:public V get(Object key)
        Integer key = maps.get("咖啡");
        System.out.println(key);    //5
        System.out.println(maps.get("可乐")); //15

        System.out.println(maps.get("石楠花水"));   //null

        //5.根据键删除整个元素(删除会返回键的值)
        System.out.println(maps.remove("咖啡"));  //5
        System.out.println(maps.remove("咖啡水")); //null
        System.out.println(maps);   //此时咖啡已经被删除
        //{null=null, 纯牛奶=10, 矿泉水=50, 可乐=15}

        //6.判断是否包含某个键,包含返回true,不包含返回false
        System.out.println(maps.containsKey("可乐")); //true
        System.out.println(maps.containsKey("百事可乐")); //false

        //7.判断是否包含某个值.
        maps.containsValue(50); //true
        maps.containsValue(51); //false

        //{}
        //8.获取全部键的集合:public Set<K> keySet()
        Set<String> keys = maps.keySet();
        System.out.println(keys);   [null, 纯牛奶, 矿泉水, 可乐]
        System.out.println(maps.keySet());  //[null, 纯牛奶, 矿泉水, 可乐]

        //9.获取全部值的集合:Collection<V> values();
        Collection<Integer> values = maps.values();
        System.out.println(values); //[null, 10, 50, 15]
        System.out.println(maps.values());  //[null, 10, 50, 15]


        //10.集合的大小
        System.out.println(maps.size());    //4

        //11.合并其他Map集合(拓展)
        Map<String, Integer> newMap = new HashMap<>();
        newMap.put("Java", 5);
        Map<String, Integer> oldMap = new HashMap<>();
        oldMap.put("C++", 5);

        newMap.putAll(oldMap); //把集合old的元素拷贝(合并)到new里面,old不发生改变
        System.out.println(newMap); //{Java=5, C++=5}
        System.out.println(oldMap); //{C++=5}
    }
}

{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
5
15
null
5
null
{null=null, 纯牛奶=10, 矿泉水=50, 可乐=15}
true
false
[null, 纯牛奶, 矿泉水, 可乐]
[null, 纯牛奶, 矿泉水, 可乐]
[null, 10, 50, 15]
[null, 10, 50, 15]
4
{Java=5, C++=5}
{C++=5}

进程已结束，退出代码为 0

4.Map集合的遍历方式一：键找值

package com.wjh_Set_Map.d7_map_traversal;


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

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

        Map<String, Integer> maps = new HashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",10);
        maps.put("可乐",15);
        maps.put("矿泉水",50);
        maps.put(null,null);
        System.out.println(maps);
        //{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}

        //1.键找值 第一步:先拿到集合的全部键
        Set<String> keys = maps.keySet();
        //2.遍历每个键,根据键提取值
        for (String k : keys) {
            Integer value = maps.get(k);    //用int出现问题
            System.out.println(k + "---->" + value);
        }

    }
}

{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null---->null
咖啡---->5
纯牛奶---->10
矿泉水---->50
可乐---->15

进程已结束，退出代码为

5.Map集合的遍历方式二：键值对

package com.wjh_Set_Map.d7_map_traversal;

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

public class MapDemo2 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",10);
        maps.put("可乐",15);
        maps.put("矿泉水",50);
        maps.put(null,null);
        System.out.println(maps);
        //{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}

        //可以通过Map的方法 entrySet把Map集合转换成Set集合形式

        //1.把Map集合转换成Set集合
        //输入maps.entrySet() 按ctrl + alt + v  自动生成
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        //2.开始遍历
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " --> " + value);
        }

        
    }
}

{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null --> null
咖啡 --> 5
纯牛奶 --> 10
矿泉水 --> 50
可乐 --> 15

进程已结束，退出代码为 0

6.Map集合的遍历方式三：lambda表达式

package com.wjh_Set_Map.d7_map_traversal;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo1 {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",10);
        maps.put("可乐",15);
        maps.put("矿泉水",50);
        maps.put(null,null);
        System.out.println(maps);
        //{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}

//        maps.forEach(new BiConsumer<String, Integer>() {
//            @Override
//            public void accept(String s, Integer integer) {
//                System.out.println(s + "--->" +integer);
//            }
//        });
        maps.forEach((key, value) -> System.out.println(key + "--->" + value));
        //JDK1.8 开始
    }
}

{null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}
null--->null
咖啡--->5
纯牛奶--->10
矿泉水--->50
可乐--->15

进程已结束，退出代码为 0

package com.wjh_Set_Map.d8_mapTest;
/*
            Map集合案例:统计投票人数
需求:
    某个班级80名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D）,
    每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
分析
    将80个学生选择的数据拿到程序中去。
    定义Map集合用于存储最终统计的结果。
    遍历80个学生选择的数据，看Map集合中是否存在，不存在存入“数据=1“，存在则其对应值+1,

 */

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        //1.把80个数据学生选择的数据拿到集合中去
        String[] selects = {"A","B","C","D"};

        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            sb.append(selects[r.nextInt(selects.length)]);
        }
        System.out.println(sb);

        //2.定义一个Map集合记录最终统计的结果
        Map<Character, Integer> maps = new HashMap<>();    //{}

        //3.遍历80个学生选择的数据
        for (int i = 0; i < sb.length(); i++) {
            //4.提取当前字符
            char ch = sb.charAt(i);
            //5.判断结合是否存在键
            if(maps.containsKey(ch)){
                //让其值+1
                maps.put(ch,maps.get(ch)+1);
            }else{
                //说明此景点是第一次被选择
                maps.put(ch,1);
            }
        }

        //输出集合
        System.out.println(maps);


    }
}

DCCCDABBADCCABADABAADCBDBBBCADBADBADDCDBABCDCDDDACDDBBAACBBCADABBDCACDBBBABCBADA
{A=20, B=23, C=16, D=21}

进程已结束，退出代码为 0

7.Map集合的实现类HashMap

8.Map集合的实现类LinkedHashMap

package com.wjh_Set_Map.d9_map_ipml;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapDemo2 {
    public static void main(String[] args) {
        //1.创建一个Map集合对象
        Map<String, Integer> maps = new LinkedHashMap<>();    //一行经典代码(多态)
        maps.put("咖啡",5);
        maps.put("纯牛奶",10);
        maps.put("可乐",15);
        maps.put("矿泉水",50);
        maps.put(null,null);
        System.out.println(maps);
        //{咖啡=5, 纯牛奶=10, 可乐=15, 矿泉水=50, null=null}
        //HashMap无序 不重复 无索引
        //LinkedHashMap有序 不重复 无索引
    }
}

{咖啡=5, 纯牛奶=10, 可乐=15, 矿泉水=50, null=null}

9.Map集合的实现类TreeMap

Map<String, Integer> map = new TreeMap<>();
        map.put("1",5);
        map.put("2",10);
        map.put("3",15);
        map.put("5",50);
        map.put("4",null);
        System.out.println(map);
        //{1=5, 2=10, 3=15, 4=null, 5=50}

package com.wjh_Set_Map.d9_map_ipml;

import java.util.Map;
import java.util.TreeMap;

public class TreeMapDemo3 {
    public static void main(String[] args) {
        //TreeMap集合自带排序;只能对键进行排序
        //可排序 去重复 无索引
        Map<Integer, String> map = new TreeMap<>();
        map.put(13,"n");
        map.put(10,"s");
        map.put(88,"c");
        map.put(2,"y");
        map.put(1,"o");

        System.out.println(map);
        //{1=o, 2=y, 10=s, 13=n, 88=c}
    }
}

Student类:

package com.wjh_Set_Map.d9_mapTest;

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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类:

package com.wjh_Set_Map.d9_mapTest;
/*
需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
          学生属性姓名和年龄，按照年龄进行排序并遍历。
思路：
定义学生类
创建TreeMap集合对象
创建学生对象
把学生添加到集合
遍历集合
 */

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class mapDemo1 {
    public static void main(String[] args) {
        //在TreeMap括号里创建比较规则
        Map<Student, String> maps = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Integer.compare(o1.getAge(), o2.getAge());
            }
        });

        maps.put(new Student("小黑子",18),"北京");
        maps.put(new Student("周扒皮",59),"上海");
        maps.put(new Student("篮球哥",16),"武汉");
        maps.put(new Student("篮球哥",16),"武汉");
        maps.put(new Student("蜘蛛侠",30),"广州");

        //1.键找值 第一步:先拿到集合的全部键
        Set<Student> keys = maps.keySet();
        //2.遍历每个键,根据键提取值
        for (Student k : keys) {
            System.out.println("姓名:" + k.getName());
            System.out.println("年龄:" + k.getAge());
            System.out.println();
        }
    }
}

姓名:篮球哥
年龄:16

姓名:小黑子
年龄:18

姓名:蜘蛛侠
年龄:30

姓名:周扒皮
年龄:59

进程已结束，退出代码为 0

package com.wjh_Set_Map.d9_mapTest;

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

/*
需求：字符串“aababcabcdabcde”
          请统计字符串中每一个字符出现的次数，并按照以下格式输出
           输出结果：
                    a（5）b（4）c（3）d（2）e（1）

 */
public class mapDemo2 {
    public static void main(String[] args) {
        //1.把字符串放入集合中
        String[] ab = {"a", "b", "c", "d", "e"};
        String s = "aababcabcdabcde";

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            sb.append(s.charAt(i));
        }
        System.out.println(sb);
        //aababcabcdabcde

        //2.定义一个Map集合记录最终结果
        Map<Character, Integer> maps = new HashMap<>();

        //3.遍历字符串的数据
        for (int i = 0; i < sb.length(); i++) {
            //4.提取当前字符
            char ch = sb.charAt(i);
            //5.判断集合是否存在键
            if(maps.containsKey(ch)){
                //让其值+1
                maps.put(ch,maps.get(ch)+1);
            }else{
                //说明是第一次选择
                maps.put(ch,1);
            }
        }
        //创建set集合
        Set<Character> keys = maps.keySet();
        //2.遍历每个键,根据键提取值
        for (Character k : keys) {
            Integer value = maps.get(k);    //用int出现问题
            System.out.print(k + " (" + value + ")");
            //a (5)b (4)c (3)d (2)e (1)
        }

    }
}

七:补充知识:集合的嵌套

package com.wjh_Set_Map.d77_mapTest;
/*
需求
    某个班级多名学生，现在需要组成秋游活动，班长提供了四个景点依次是（A、B、C、D）,
    每个学生可以选择多个景点，请统计出最终哪个景点想去的人数最多。

分析
    将80个学生选择的数据拿到程序中去，需要记住每个学生选择的情况。
    定义Map集合用于存储最终统计的结果。
 */

import java.util.*;

public class ABCD {
    public static void main(String[] args) {
        //1.把80个数据学生选择的数据拿到集合中去
        //使用哟个Map集合储存
        Map<String, List<String>> date = new HashMap<>();
        String[] selects = {"A","B","C","D"};
        Random r = new Random();




        //2.把学生选择的数据存入进去.
        List<String> list = new ArrayList<>();
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<String> list3 = new ArrayList<>();
        Collections.addAll(list,"A","C");
        Collections.addAll(list1,"A","B","C");
        Collections.addAll(list2,"A","B","C","D");
        Collections.addAll(list3,"A","C","D");
        date.put("罗勇",list);
        date.put("娜娜",list1);
        date.put("明明",list2);
        date.put("嘻嘻",list3);
        System.out.println(date);

        //3.统计每个选择的人数
        Map<String, Integer> maps = new HashMap<>();


        //4.提取所有人选择的景点数据信息
        Collection<List<String>> values = date.values();
        //value = []

        for (List<String> v: values) {
            for (String s : v) {
                //有没有包含这个景点
                if (maps.containsKey(s)){
                    maps.put(s, maps.get(s) + 1);
                }else{
                    maps.put(s,1);
                }
            }
        }
        System.out.println(maps);
  //{嘻嘻=[A, C, D], 娜娜=[A, B, C], 明明=[A, B, C, D], 罗勇=[A, C]}
//{A=4, B=2, C=4, D=2}

    }
}

{嘻嘻=[A, C, D], 娜娜=[A, B, C], 明明=[A, B, C, D], 罗勇=[A, C]}
{A=4, B=2, C=4, D=2}

进程已结束，退出代码为 0

程序员希西子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java Collection体系特点 Set集合体系 Map集合体系

Collection体系特点 Set集合体三.补充知识:可变参数 4.Map集合的遍历方式一：键找值5.Map集合的遍历方式二：键值对 {null=null, 咖啡=5, 纯牛奶=10, 矿泉水=50, 可乐=15}null --> null咖啡 --> 5纯牛奶 --> 10矿泉水 --> 50可乐 --> 15进程已结束，退出代码为 0 9.Map集合的实现类T
复制链接

扫一扫