JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合

XXXZhy

已于 2022-04-28 21:19:51 修改

阅读量817

点赞数

分类专栏： JAVA进阶笔记文章标签： JAVA

于 2022-04-14 09:02:19 首次发布

本文链接：https://blog.csdn.net/qq_35982918/article/details/124141278

版权

JAVA进阶笔记专栏收录该内容

18 篇文章 9 订阅

订阅专栏

系列文章目录

JavaSE进阶01：继承、修饰符
 JavaSE进阶02：多态、抽象类、接口
 JavaSE进阶03：内部类、Lambda表达式
 JavaSE进阶04：API中常用工具类
 JavaSE进阶05：包装类、递归、数组的高级操作、异常
 JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
 JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
 JavaSE进阶09：Stream流、File类
 JavaSE进阶10：IO流、字节流、字节缓冲流
 JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
 JavaSE进阶12：多线程、线程同步、线程池
 JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
 JavaSE进阶14：类加载器、反射
 JavaSE进阶15：XML、注解、单元测试
 JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
 Java进阶作业

1.HashSet集合

1.1HashSet集合概述和特点【应用】

底层数据结构是哈希表
存取无序
不可以存储重复元素
没有索引,不能使用普通for循环遍历
哈希元素不可比较

1.2HashSet集合的基本应用【应用】

存储字符串并遍历

import java.util.HashSet;
public class HashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");
        //遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}
/*
world
java
hello 
*/

1.3哈希值【理解】

哈希值简介

哈希值（哈希码值）是JDK根据对象的地址或者属性值算出来的int类型的数值

如何获取哈希值

Object类中的public int hashCode()：返回对象的地址值算出来的哈希值
对象的哈希值的特点
- 如果没有重写hashCode()方法，那么是根据对象的地址值计算出哈希值。
  - 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 如果重写了hashCode()方法，一般通过对象的属性值计算出哈希值。
  - 如果不同对象的属性值是一样的，那么计算出的哈希值也是一样的。

1.4哈希表结构【理解】

加载因子决定了什么时候扩容，数组默认长度为16，加载因子默认为0.75。16*0.75=12，也就是当数组存了12个元素的时候，数组会扩容为原先的2倍。
底层扩容非常消耗性能，项目开发中最好指定数组长度initialCapacity。

JDK1.8以前
数组 + 链表
JDK1.8即以后
- 优化问题
  JDK1.7中的链表如果非常长，又要将链表中所有元素都比较一次，影响性能
- 节点个数少于等于8个
  数组 + 链表
- 节点个数多于8个且数组长度>=64
  数组 + 红黑树

1.5HashSet集合存储学生对象并遍历【应用】

注意事项

HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
IDEA重写快捷键：Alt+Ins->equals() and hashCode() 后一直下一步。
案例需求
- 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
- 要求：学生对象的成员变量值相同，我们就认为是同一个对象

/*学生类*/
import java.util.Objects;
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;
    }

    //Alt+Ins->equals() and hashCode() 一直下一步。
    @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);
    }
}

/*测试类*/
import java.util.HashSet;
public class HashSetDemo02 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Student> hs = new HashSet<Student>();

        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 35);
        Student s3 = new Student("王五", 33);

        Student s4 = new Student("王五", 33);

        //把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        //遍历集合(增强for)
        for (Student s : hs) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}
/*
王五,33
李四,35
张三,30
*/

1.6 为什么HashSet无序添加整型却输出有序

Hashset实现原理：
Hashset底层使用HashMap来实现的，Set的元素存放在Map的Key上面。
对于hashmap来讲，它的主体是一个Entry数组，Entry又是一个链表。

Hashmap的存储过程如下：
1.计算Key的Hash值
2.把得到的Hash值作为数据下标去存储到Entry的数组中。在这里可能出现不一样的Key的得到的Hash值相等，相同的Hash值存在同一个数组元素下组成链表。（Entry是个结点，多个节点组成链表）

HashSet实际上存储元素的时候进行了获取Hash的操作，整形的Hash值就是自身，所以根据这个hash值得到数组的下标存储元素后，表现出来就是有序的。

TreeSet实现原理
TreeSet的底层使用treemap实现的，Set的元素存放在Map的Key上面.

TreeMap又是用红黑树进行实现，实际上红黑树是一种自平衡二叉查找树，它满足元素的有序性，因此TreeSet的元素是具有有序性的。

TreeSet和TreeMap当泛型是自定义类型时，底层没有相应的比较方法，就必须重写比较方法。

2.Map集合

2.1Map集合概述和特点【理解】

Map集合概述、
- Map为双列集合，一次存两个元素。
- Map是个接口，只能通过多态的形式实例化。
- (键+值)这个整体称为键值对，在java中又叫Entry对象。

interface Map<K,V>  K：键的类型；V：值的类型

Map集合的特点
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复
- put相同键，后值覆盖前值

import java.util.*;
public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("itheima001","张三");
        map.put("itheima002","李四");
        map.put("itheima003","王五");
        map.put("itheima001","赵六");
        map.put(null,"null1");
        map.put(null,"null2");     
        //输出集合对象
        System.out.println(map);//{null=null2, itheima003=王五, itheima001=赵六, itheima002=李四}
    }
}

2.2Map集合的基本功能【应用】

方法介绍

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

import java.util.*;
public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key,V value)：添加元素
        map.put("张三","张三老婆");
        map.put("李四","李四老婆");

        // remove(Object key)：根据键删除键值对元素
        System.out.println(map.remove("李四"));//李四老婆
        System.out.println(map.remove("李哥"));//null

        //void clear()：移除所有的键值对元素
        map.clear();
        System.out.println(map);//{}
        
        //boolean containsKey(Object key)：判断集合是否包含指定的键
        map.put("王五","王五老婆");
        System.out.println(map.containsKey("王五"));//true
        System.out.println(map.containsKey("王哥"));//false

        //boolean isEmpty()：判断集合是否为空
        System.out.println(map.isEmpty());//false

        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());//1

        //输出集合对象
        System.out.println(map);//{王五=王五老婆}
    }
}

2.3Map集合的获取功能【应用】

方法介绍

方法名说明
V get(Object key) 根据键获取值
Set keySet() 获取所有键的集合
Collection values() 获取所有值的集合
Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

import java.util.*;
public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("1号丈夫", "1号妻子");
        map.put("2号丈夫", "2号妻子");
        map.put("3号丈夫", "3号妻子");
        
        System.out.println("---keySet():获取所有键的集合---");
        System.out.println(map.get("1号丈夫"));
        System.out.println(map.get("5号丈夫"));
        
        System.out.println("---keySet():获取所有键的集合---");
        Set<String> keySet = map.keySet();
        for(String key : keySet) {
            System.out.println(key);
        }
        System.out.println("---Collection<V> values():获取所有值的集合---");
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }        
    }
}

2.4Map集合的遍历的四种方式【应用】

import java.util.*;
import java.util.function.BiConsumer;
public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<>();
        //添加元素
        map.put("张三", "张三老婆");
        map.put("李四", "李四老婆");
        map.put("王五", "王五老婆");

        Set<String> keySet = map.keySet();//获取所有键的集合。用keySet()方法实现
        System.out.println("---方式一：增强for(键:键对象)---");
        for (String key : keySet) { //遍历键的集合，获取到每一个键。用增强for实现
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + ",,," + value);
        }

        System.out.println("---方式二：增强for（键值对:键值对对象）---");
        Set<Map.Entry<String, String>> entrySet1 = map.entrySet();//获取所有键值对对象的集合
        for (Map.Entry<String, String> me : entrySet1) {//遍历键值对对象的集合，得到每一个键值对对象
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "。。。" + value);
        }

        System.out.println("---方式三：迭代器while()---");
        Set<Map.Entry<String, String>> entrySet2 = map.entrySet();//获取所有键值对对象的集合
        Iterator<Map.Entry<String, String>> iterator = entrySet2.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "---" +value);
        }

        System.out.println("---方式四：forEach(匿名内部类BiConsumer)---");
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println(s+"--->"+s2);
            }
        });

        System.out.println("---方式四：forEach(Lambda表达式)---");
        map.forEach((s,s2)-> System.out.println(s+"--->"+s2));
    }
}
/*
---方式一：增强for(键:键对象)---
李四,,,李四老婆
张三,,,张三老婆
王五,,,王五老婆
---方式二：增强for（键值对:键值对对象）---
李四。。。李四老婆
张三。。。张三老婆
王五。。。王五老婆
---方式三：迭代器while()---
李四---李四老婆
张三---张三老婆
王五---王五老婆
---方式四：forEach(匿名内部类BiConsumer)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
---方式四：forEach(Lambda表达式)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
*/

forEach在底层实质就是增强for循环。
在这里插入图片描述

3.HashMap集合

3.1HashMap集合概述和特点【理解】

HashMap是Map里面的一个实现类
HashMap跟HashSet一样底层是哈希表结构的

在底层和HashSet一样，1.8以前是数组+链表；1.8及以后是少于等于8个为数组+链表，多余1.8为数组+红黑树；只是存入的是Entry对象。
依赖hashCode方法和equals方法保证键的唯一
如果键要存储的是自定义对象，需要重写hashCode和equals方法，因为底层是按照自定义对象的地址值比较的，一般需求是按照数值内容比较。
值存储的是自定义对象，无所谓重写与否，只用保证键唯一

3.2HashMap集合应用案例【应用】

案例需求
- 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
- 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

/*学生类*/
import java.util.Objects;

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

    //Alt+Ins->equals() and hashCode() 一直下一步。
    @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);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



/*实现类*/
import java.util.*;
public class HashMapStudentDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<Student, String>();

        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 35);
        Student s3 = new Student("王五", 33);
        Student s4 = new Student("王五", 33);

        //把学生添加到集合
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");

        //遍历集合
        hm.forEach((Student key,String value)-> System.out.println(key+"----"+value));
    }
}
/*
Student{name='王五', age=33}----北京
Student{name='李四', age=35}----武汉
Student{name='张三', age=30}----西安
 */

4.TreeMap集合

4.1TreeMap集合概述和特点【理解】

TreeMap和TreeSet一样，底层是红黑树结构
依赖自然排序或者比较器排序,对键进行排序
如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

自然排序compareTo()原理：
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边

4.2TreeMap集合应用案例【应用】

案例需求
- 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
- 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序

/*学生类*/
package lesson;

public class Student implements Comparable<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 +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照年龄进行排序
        int result = o.getAge() - this.getAge();
        //次要条件，按照姓名排序。
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
}
/*测试类*/
package lesson;

import java.util.TreeMap;

public class TreeMapStudentDemo {
    public static void main(String[] args) {
        // 创建TreeMap集合对象
        TreeMap<Student,String> tm = new TreeMap<>();

        // 创建学生对象
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);

        Student s4 = new Student("xiaomei",22);

        // 将学生对象添加到TreeMap集合中
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");

        tm.put(s4,"天津");

        // 遍历TreeMap集合,打印每个学生的信息
        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
    }
}
/*
Student{name='xiaohei', age=23}---江苏
Student{name='xiaomei', age=22}---天津
Student{name='dapang', age=22}---北京
 */

5.可变参数（参数个数不确定）

可变参数介绍
- 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
- 方法的参数类型已经确定,个数不确定,我们可以使用可变参数
- 我们在JDK5之前会把所有参数先放到一个数组中，然后在自定义方法的形参值写一个数组就行。而可变参数就是帮我们实现省略了这一步。
可变参数定义格式

  修饰符 返回值类型 方法名(数据类型… 变量名) {  }

可变参数的注意事项
- JAVA的可变参数会被编译器转型成一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后。
- 由于可变必须最后一个，所以一个方法中最多也只能由一个可变参数

/*
需求：定义一个方法球N个数的和，用可变参数实现
 */
public class MyVariableParameter {
    public static void main(String[] args) {
        int sum=getSum("123",1,2,3,4,5,6);//多个参数时，可变参数必须放最后
        System.out.println(sum);
    }
    public static int getSum(String s,int...arr){
        System.out.println("我是不可变参数"+s);
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
}
/*
我是不可变参数123
21
 */

6.创建不可变集合

方法介绍
是JDK9出现的方法。

方法	介绍
static List of(E…elements)	创建一个具有指定元素的List集合对象
static Set of(E…elements)	创建一个具有指定元素的Set集合对象
static <K , V> Map<K，V> of(E…elements)	创建一个具有指定元素的Map集合对象

在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合
- 这个集合不能添加,不能删除,不能修改。
- 但是可以结合集合的带参构造,实现集合的批量添加。
在Map接口中,还有一个Map.ofEntries方法可以提高代码的阅读性
- 首先用Map.entry把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中
注意事项
- Set集合中的of方法不能有重复的元素
- Map.ofEntries方法创建的也是不可变集合

package homeWork2;

import java.util.*;

public class MyVariableParameter4 {
    public static void main(String[] args) {
        method1();//of方法创建的不可变的集合不能整删改
        //method2();//Set.off方法不可重复元素
        method3();//Map.of创建不可变键值对集合
        method4();//Map.entry提高阅读性
        method5();//集合批量添加元素

    }

    private static void method5() {
        //首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。
        //再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。
        ArrayList<String> list2 = new ArrayList<>(List.of("a", "b", "c"));

        Collections.addAll(list2, "1","2","3");//批量添加方式1
        list2.addAll(Arrays.asList("A","B","C"));批量添加方式2

        System.out.println(list2);//[a, b, c, 1, 2, 3, A, B, C]
    }

    private static void method4() {
        Map<String, String> map = Map.ofEntries(
                Map.entry("zhangsan", "江苏"),
                Map.entry("lisi", "北京"));
        System.out.println(map);//{lisi=北京, zhangsan=江苏}

    }

    private static void method3() {
        Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
        System.out.println(map);//{zhangsan=江苏, lisi=北京, wangwu=天津}
    }

    private static void method2() {
        //传递的参数当中，不能存在重复的元素。
        Set<String> set = Set.of("a", "b", "c", "d","a");//报错
    }

    private static void method1() {
        List<String> list = List.of("a", "b", "c", "d");
        //list.add("Q");//添加报错
        //list.remove("a");//删除报错
        //list.set(0,"A");//修改报错
    }
}

XXXZhy

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合

系列文章目录JavaSE进阶01：继承、修饰符JavaSE进阶02：多态、抽象类、接口JavaSE进阶03：内部类、Lambda表达式JavaSE进阶04：API中常用工具类JavaSE进阶05：包装类、递归、数组的高级操作、异常JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedListJavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树Java进阶作业文章目录系列文章目录1.HashSet集合1.1HashSet集合概述
复制链接

扫一扫