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

系列文章目录

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()获取所有键值对对象的集合
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");//修改报错
    }
}
  • 0
    点赞
  • 1
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:数字20 设计师:CSDN官方博客 返回首页
评论

打赏作者

XXXZhy

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值