Java集合，全体起立

一、集合框架的概述

⛳️1、集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt, .jpg, .avi, 数据库)

2.1、数组在存储多个数据方面的特点：
① 一旦初始化以后，其长度就确定了；
② 数组一旦定义好，其元素的类型也就确定了。
比如：String [ ] arr; int [ ] arr1; Object [ ] arr2;

2.2、数组在存储多个数据方面的缺点：
① 一旦初始化以后，其长度就不可修改；
② 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高；
③ 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用；
④ 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二、集合框架

具体讲到各个的实现类

|--------Collection接口:单列集合，用来存储一个一个的对象
    |--------list接口:存储有序的、可重复的数据      --->"动态"数组
         |--------ArrayList、LinkedList、Vector
    |--------Set接口:存储无序的、不可重复的数据    --->高中阶段所讲过的“集合”
         |--------HashSet、LinkedHashSet、TreeSet

|-------Map接口：双列集合，用来存储一对(key-value)一对的数据    --->高中函数：y = f(x)
    |--------HashMap、LinkedHashMap、TreeMap、HashTable、Properties

三、Collection接口中的方法的使用

常用的14种方法如下所示：
Collection coll = new AarryList( );
① coll.add(Object e)
② coll.size( ):获取添加元素的个数
③ coll.addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
④ coll.clear( ):清空集合元素
⑤ coll.isEmpty( ):判断当前集合是否为空
⑥ coll.contains(Object obj):判断当前集合汇总是否包含obj，在判断时会调用obj对象所在类的equals( )
⑦ coll.containsAll(Collection coll2):判断形参coll2中的所有元素是否存在于当前集合中
⑧ coll.remove(Object obj):从当前集合中删除obj元素，删除成功返回TRUE,删除失败返回FALSE
⑨ coll.removeAll(Object coll1):从当前集合中移除coll1中所有元素(差集)
⑩ coll.retainAll(Collection coll1):获取当前集合和coll1集合的交集，并返回给前端集合(交集)
⑪ coll.equals(Object obj):要想返回TRUE，需要当前集合和形参集合的元素相同(有顺序之分！顺序不同，不能返回TRUE)
⑫ coll.hashCode( ):返回当前对象的哈希值
⑬ coll.toArray( ):集合转换为数组
扩展：数组转换为集合，调用Arrays类的静态方法asList( ),"{ }"中的元素为可变形参
⑭ coll.iterator( ):返回Iterator接口的实例，用于遍历集合元素

注意：(非常重要的结论)向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()方法。

常用的14种方法代码演示如下：

public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        //1.add(Object e):
        coll.add("AA");
        coll.add("BB");
        coll.add("CC");
        coll.add("123");
        coll.add(new Date());

        //2.size():获取添加元素的个数
        System.out.println(coll.size());//5

        //3.addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add("DD");
        coll1.add(456);
        coll.addAll(coll1);
        System.out.println(coll.size());//7
        System.out.println(coll);

        //4.clear():清空集合元素
        coll.clear();

        //5.isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());

        //6.contains(Object obj):判断当前集合中是否包含obj
        //在判断时会调用obj对象所在类的equals()
        coll.add(new Person("Jerry",24));
        coll.add(123);
        coll.add(false);
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new Person("Jerry", 24)));//重写equals方法，内容相同输出true

        //7.containsAll(Collection coll2):判断形参coll2中的所有元素是否存在于当前集合中
        Collection coll2 = Arrays.asList("123",false);//asList:可变形参方法
        System.out.println(coll.containsAll(coll2));
    }

    @Test
    public void test2(){
        //8.remove(Object obj):从当前集合中删除obj元素，删除成功返回TRUE，删除失败返回FALSE。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        coll.remove(123);
        System.out.println(coll);
        coll.remove(new Person("Jerry",25));
        System.out.println(coll);

        //9.removeAll(Collection coll1):从当前集合中移除coll1中所有的元素(差集)
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);//coll与coll1做差集，公共部分移除。
        System.out.println(coll);
    }

    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        //10.retainAll(Collection coll1):获取当前集合和coll1集合的交集，并返回给当前集合(交集)
        Collection coll1 = Arrays.asList(123,456,789);
        coll.retainAll(coll1);
        System.out.println(coll);

        //11.equals(Object obj):要想返回TRUE，需要当前集合和形参集合的元素相同(有顺序之分！顺序不同，不能返回TRUE)
        Collection coll2 = new ArrayList();
        coll2.add(123);
        coll2.add(456);
        coll2.add(new String("Tom"));
        coll2.add(new Person("Jerry",25));
        coll2.add(false);

        System.out.println(coll.equals(coll2));

    }

    @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        //12.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //13.toArray():集合转换为数组
        Object[] array = coll.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        //扩展:数组转换为集合，调用Arrays类的静态方法asList(),“{ }”中的元素为可变形参。
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);//调用toString方法

        List<int[]> list1 = Arrays.asList(new int[]{123, 456});//基本数据类型把它当成了一个整体,当成一个参数了
        System.out.println(list1);

        List<Integer> list2 = Arrays.asList(new Integer[]{123, 456});//而包装类则可以区分开！(开发中的小细节)
        System.out.println(list2);

        //14.iterator():返回iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中进行测试
    }
}

package com.java.collection;

import java.util.Objects;

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

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("Person equals......");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

}

四、集合元素的遍历

集合元素的遍历操作，使用迭代器Iterator接口(用于Collection,不用于Map)
⛳️1.内部方法：hasNext() 和 next()
(1) hasNext():判断是否还有下一个元素
(2) next(): ①指针下移; ②将下移以后集合位置上的元素返回
注意: iterator只是用于遍历的迭代器，它不是容器。“为容器而生！”

⛳️2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。(避开两种错误方式)

⛳️3.内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于Collection中直接调用的remove()方法,要注意区分。

⛳️4.如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException

package com.java.collection;

import org.junit.Test;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @description:
 * @author: Fish_Vast
 * @Date: 2021/10/9
 * @version: 1.0
 */
public class IteratorTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        Iterator iterator = coll.iterator();

        //方式一:不推荐
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());

        //方式二:不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        //方式三:推荐(开发中)
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        Iterator iterator = coll.iterator();
//        //错误方式一:①跳着输出，②报异常:NoSuchElementException
//        while (iterator.next() != null){
//            System.out.println(iterator.next());
//        }
        //错误方式二:死循环
//        while (coll.iterator().hasNext()){
//            System.out.println(coll.iterator().next());
//        }
    }

    //测试Iterator中的remove(),使用频率不高。
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new String("Tom"));
        coll.add(new Person("Jerry",25));
        coll.add(false);

        //删除集合中的"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object object = iterator.next();
            if ("Tom".equals(object)){
                iterator.remove();
            }
        }

        //遍历集合,因为上述删除操作已经将集合容器中的元素全部遍历了一遍，下次遍历之前需要重新生成新的迭代器对象才能实现集合的遍历。
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//“Tom”已经被移除
        }
    }

    @Test
    public void test4(){
        int a=9;
        int b=7;
        DecimalFormat df=new DecimalFormat("0.00");

        System.out.println(df.format((float)a/b));
        System.out.println(df.format(a/(float)b));
        System.out.println(df.format((float)a/(float)b));
        System.out.println(df.format((float)(a/b)));
    }

}

五、List接口框架

|--------Collection接口:单列集合，用来存储一个一个的对象
     |--------list接口:存储有序的、可重复的数据      --->"动态"数组,替换原有的数组
           |--------ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用Object[] elementData存储
           |--------LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
           |--------Vector：作为List接口的古老实现类；线程安全，效率低；底层使用Object[] elementData存储

⛳️1.ArrayList、LinkedList、Vector有何异同？
同：三个类都实现了List接口，存储数据特点相同：存储有序的、可重复的数据
异：见上的三个分析

⛳️2.ArrayList的源码分析

2.1(jdk 7 的情况下)
ArrayList list = new ArrayList();//底层创建了长度为10的Object[ ]数组elementData
list.add(123);//elementData[0] = new Integer(123);
… … … …
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

2.2(jdk 8 的情况下的变化)
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{ },并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]
… … … …
后续的添加和扩容与jdk 7 无异

2.3小结：jdk 7 中的ArrayList的对象创建类似于单例的饿汉式；而jdk 8 中的ArrayList的对象创建类似于单例的懒汉式，延迟了数组的创建，节省了内存。

⛳️3.LinkedList的源码分析
LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。

其中Node定义为：体现了LinkedList的双向链表的说法

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

   Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
       }
    }

⛳️4.Vector的源码分析
jdk7 和jdk8 中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍

⛳️5.List接口中的方法
① void add(int index, Object ele):在index位置插入ele元素
② boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
③ Object get(int index):获取指定index位置的元素
④ int indexOf(Object obj):返回obj在集合中首次出现的位置
⑤ int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
⑥ Object remove(int index):移除指定index位置的元素，并返回此元素
⑦ Object set(int index, Object ele):设置指定index位置的元素为ele
⑧ List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

⛳️总结：常用方法
增：add(Object obj)
删：remove(int index)、remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：①Iterator迭代器方式；②增强for循环(增强型for循环，本人这篇博文对其有详细介绍！)；③普通的for循环

package com.java.collection;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * @description:
 * @author: Fish_Vast
 * @Date: 2021/10/9
 * @version: 1.0
 */
public class ListTest {

    //区分list中的remove(int index)和remove(Object obj)-->开发中注意别用错了  笔试题
    @Test
    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//[1]
    }
    private static void updateList(List list) {
        list.remove(2);//删除的是索引
        list.remove(new Integer(2));//删除的是数值为2的对象
    }

    //遍历操作
    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器的方式
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("***********");
        //方式二：增强for循环
        for(Object object : list){
            System.out.println(object);
        }
        System.out.println("***********");
        //方式三：普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }


    @Test
    public void test1(){
        //以ArrayList()为例，因为它是常用的实现类
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",28));
        list.add(789);

        System.out.println(list);
        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");

        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

        //int indexOf(Object obj):返回obj在集合中首次出现的位置,如果不存在,则返回-1。
        int index = list.indexOf(456);
        System.out.println(index);

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        int index1 = list.lastIndexOf(456);
        System.out.println(index1);

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
        System.out.println(list.subList(3, 5));
    }
}

六、Set接口框架

|--------Collection接口:单列集合，用来存储一个一个的对象
     |--------Set接口:存储无序的、不可重复的数据    --->高中阶段所讲过的“集合”
           |--------HashSet:作为Set接口的主要实现类；线程不安全的；可以存储null值
                 |--------LinkedHashSet:作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历
           |--------TreeSet:可以按照添加对象的指定属性，进行排序 

⛳️注意: Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
⛳️要求: 向Set添加的数据，其所在的类一定要重写hashCode()和equals();
重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码(即哈希值)

⛳️1.Set：存储无序的、不可重复的数据
以HashSet为例说明：
(1)无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
(2)不可重复性：保证添加的元素按照equals()判断时，不能返回TRUE，即相同的元素只能添加一个

⛳️2.添加元素的过程(理解即可)
以HashSet为例：
我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法,计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为：索引位置)，判断数组此位置上是否已经有元素：

 （1）如果此位置上没有其他元素，则元素a添加成功 --->情况1
 （2）如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
     ---（1）如果hash值不相同，则元素a添加成功 --->情况2
     ---（2）如果hash值相同，进而需要调用元素a所在类的equals()方法：
         ---（1）equals()返回TRUE，元素a添加失败
         ---（2）equals()返回FALSE，则元素a添加成功 --->情况3
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

jdk 7 ：元素a放在数组中，指向原来的元素
jdk 8 ：原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的结构

⛳️3.LinkedHashSet的作用
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

⛳️4.TreeSet的使用：
① 向TreeSet中添加的数据，要求是相同类的对象
② 两种排序方式：自然排序(实现Comparable接口) 和 定制排序(Comparator)
③ 自然排序中，比较两个对象是否相同的标准为：compareTo() 返回0，不再是equals()
④ 定制排序中，比较两个对象是否相同的标准为：compare() 返回0，不再是equals()

package com.java.collection;

import org.junit.Test;

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

/**
 * @description:
 * @author: Fish_Vast
 * @Date: 2021/10/9
 * @version: 1.0
 */
public class SetTest {
    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(123);
        set.add(123);
        set.add(456);
        set.add(789);
        set.add("AA");
        set.add("CC");
        set.add(new User("Jerry",26));
        set.add(new User("Jerry",26));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(123);
        set.add(123);
        set.add(456);
        set.add(789);
        set.add("AA");
        set.add("CC");
        set.add(new User("Jerry",26));
        set.add(new User("Jerry",26));

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

package com.java.collection;

import java.util.Objects;

/**
 * @description:
 * @author: Fish_Vast
 * @Date: 2021/10/11
 * @version: 1.0
 */
public class User implements Comparable{
    private String name;
    private int age;

    public User() {
    }

    public User(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 "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("hashSet.equals()......");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

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


    @Override //User类要实现Comparable接口，才可以重写compareTo
    public int compareTo(Object o){
        if (o instanceof User){
            User user = (User) o;
            int compare = - this.name.compareTo(user.name);
            if(compare != 0){
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else {
            throw new RuntimeException("输入的类型不匹配！");
        }
    }

}

七、Map的实现类的结构

|---Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y=f(x)
    |---HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value
         |---LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历
         原因: 在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素对于频繁的遍历操作，此类执行效率高于HashMap
    |---TreeMap: 保证按照添加的key-value对(键值对)进行排序，实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树
    |---Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value
         |---Properties:常用来处理配置文件。key和value都是String类型

HashMap的底层: 数组+链表(jdk7及之前)
              数组+链表+红黑树(jdk8)

⛳️1、Map结构的理解：
Map中的key：无序的、不可重复的，使用Set存储所有的key —>key所在的类要重写equals()和hashCode() (以HashMap为例)
Map中的value：无序的、可重复的，使用Collection存储所有的value —>value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry：无序的、不可重复的，使用Set存储所有的entry

⛳️2、HashMap的底层实现原理？以jdk7为例说明：
HashMap map = new HashMap():
在实例化以后，底层创建了长度是16的一维数组Entry[] table。
…可能已经执行过多次put…
map.put(key1, value1):

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
如果此位置上的数据为空，此时的key1-value1添加成功。--->情况1
如果此位置上的数据不为空(意味着此位置上存在一个或多个数据(以链表形式存在))，比较key1和已经存在的一个或多个数据的哈希值：
    如果key1的哈希值与已存在的数据的哈希值都不相同，此时key1-value1添加成功。--->情况2
    如果key1的哈希值和已存在的某一个数据的哈希值相同，继续比较：调用key1的所在类的equals()方法，比较：
        如果equals()返回false:此时key1-value1添加成功。--->情况3
        如果equals()返回true:使用value1替换相同key的value值。
补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，默认的方式：扩容为原来容量的2倍，并将原有的数据复制过来。

jdk8相较于jdk7在底层实现方面的不同：
1.new HashMap()：底层没有创建一个长度为16的数组
2.jdk8底层的数组是：Node[],而非Entry[]
3.首次调用put()方法时，底层创建长度为16的数组
4.jdk7底层结构只有：数组+链表。 jdk8中底层结构：数组+链表+红黑树。
当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树存储。

DEFAULT_INITIAL_CAPACITY:HashMap的默认容量为16
DEFAULT_LOAD_FACTOR:HashMap的默认加载因子：0.75
threshold:扩容的临界值=容量填充因子：160.75 => 12
TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量：64

⛳️3、LinkedHashMap的底层实现原理(了解)
源码中：

static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after; //能够记录添加的元素的先后顺序
        Entry(int hash, K key, V value, Node<K,V> next) {
           super(hash, key, value, next);
         }
    }

⛳️4、Map中定义的方法

添加、 删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等

元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法
添加：Object put(Object key,Object value)
删除：Object remove(Object key)
修改：Object put(Object key,Object value)
查询：Object get(Object key)
长度：size()
遍历：keySet() / values() / entrySet()

package com.java.collection;
import org.junit.Test;
import java.util.*;

/**
 * @description:
 * @author: Fish_Vast
 * @Date: 2021/10/11
 * @version: 1.0
 */
public class MapTest {
    @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println();

        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }

        System.out.println();

        //遍历所有的key-value：entrySet()
        Set set1 = map.entrySet();
        Iterator iterator1 = set1.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj; //这里进行了一次强制类型转换
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }
    }
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",456);

    }
    @Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123); //输出的等号只是用来区分key和value而已，不是赋值符号
        map.put("BB",456);
        //修改
        map.put("AA",11);
        map.put("BB",22);
        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        //putAll(Map map)
        map.putAll(map1);
        System.out.println(map);
        //remove(key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();
        System.out.println(map.size());
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new LinkedHashMap();

        map.put(123,"AA");
        map.put(456,"BB");
        map.put(789,"CC");

        System.out.println(map);
    }

    @Test
    public void test1(){
        HashMap map = new HashMap();
        map.put(null,123);
    }
}

⛳️5.TreeMap

TreeMap的key的排序：
① 自然排序：TreeMap的所有的key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException。

② 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。此时不需要Map的key实现Comparable接口

TreeMap判断两个key相等的标准：两个key通过compareTo( )方法或者compare( )方法返回0。

八、Collections工具类

排序操作：（均为static方法）
① reverse(List)： 反转 List 中元素的顺序
② shuffle(List)： 对 List 集合元素进行随机排序
③ sort(List)： 根据元素的自然顺序对指定 List 集合元素按升序排序
④ sort(List， Comparator)： 根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
⑤ swap(List， int， int)： 将指定 list 集合中的 i 处元素和 j 处元素进行交换

查找、替换：
① Object max(Collection)： 根据元素的自然顺序，返回给定集合中的最大元素
② Object max(Collection， Comparator)： 根据 Comparator 指定的顺序，返回给定集合中的最大元素
③ Object min(Collection)
④ Object min(Collection， Comparator)
⑤ int frequency(Collection， Object)： 返回指定集合中指定元素的出现次数
⑥ void copy(List dest,List src)：将src中的内容复制到dest中
⑦ boolean replaceAll(List list， Object oldVal， Object newVal)： 使用新值替换List 对象的所有旧值

路过的小伙伴，如果博文有帮助到你解决问题，可以点赞+收藏+关注一波呀~本人将会持续更新相关Java学习的博文，感谢您的支持哦！！！芜湖起飞✈️✈️✈️