java集合（超详细）

痛定思痛。 2023-09-28 19:25 11阅读 0赞

## 1 - 概述 ##

所有的集合类和集合接口都在java.util包下。

在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种**引用数据类型**。

## 2 - 集合与数组的区别 ##

长度区别

数组长度固定，定义长了造成内存空间的浪费，定义短了不够用。

集合大小可以变，用多少空间拿多少空间。

内容区别

数组可以存储基本数据类型和引用数据类型

集合中能存储引用数据类型（存储的为对象的内存地址）

list.add(100);//为自动装箱，100为Integer包装的

元素区别

数组中只能存储同一种类型成员

集合中可以存储不同类型数据（一般情况下也只存储同一种类型的数据）

集合结构

在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中  
存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的  
结构就是数据结构。不同的数据结构，数据存储方式不同。

*  单列集合 **Collection**
    
     *  **List**可以重复：*ArrayList/LinkedList*
     *  **Set**不可重复：*HashSet/TreeSet*
     *  ![7365658cde9840a5aa4cf2dcc0de115b.png][]
        
        --------------------
        
        （大量文字插入会导致图片不清，所以在此进行更详细的描述）
     *  List特点：此处顺序并不是大小顺序，而是存入数据的先后顺序。有序因为List集合都有下标，下标从0开始，以递增。
     *  Set特点：取出顺序不一定为存入顺序，另外Set集合没有下标。
     *  ArrayList是非线程安全的。
     *  HashSet集合在new的时候，底层实际上new了一个HashMap集合。向HashSet集合中存储元素，实际上是存储到了HashMap的key中了。HashMap集合是一个Hash表数据结构。
     *  SortedSet集合存储元素的特点：由于继承了Set集合，所以他的特点也是无序不可重复，但是放在SortedSet集合中的元素可以自动排序。放到该集合中的元素是自动按照大小顺序排序的。
     *  TreeSet集合底层实际上是TreeMap。TreeSet集合在new的时候，底层实际上new了一个TreeMap集合。向TreeSet集合中存储元素，实际上是存储到了TreeMap的key中了。TreeMap集合是一个二叉树数据结构。
 *  双列集合**Map**:*HashMap/TreeMap*

![d64de167f8ec4e32b9a03b28995e3c7e.png][]

> 粗体是接口 斜体是实现类

## 3 - Collection集合 ##

### 3.1 - 概述 ###

> 单列集合的顶层接口，既然是接口就不能直接使用，需要通过实现类！~

### 3.2 - Collection集合的的常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>boolean add(E e)</code></td> 
   <td>添加元素到集合的末尾（追加）</td> 
  </tr> 
  <tr> 
   <td><code>boolean remove(Object o)</code></td> 
   <td>删除指定的元素，成功则返回true（底层调用equles）</td> 
  </tr> 
  <tr> 
   <td><code>void clear()</code></td> 
   <td>清空集合</td> 
  </tr> 
  <tr> 
   <td><code>boolean contains(Object o)</code></td> 
   <td>判断元素在集合中是否存在，存在则返回true（底层调用equles）</td> 
  </tr> 
  <tr> 
   <td><code>boolean isEmpty()</code></td> 
   <td>判断集合是否为空，空则返回true</td> 
  </tr> 
  <tr> 
   <td><code>int size()</code></td> 
   <td>返回集合中元素个数</td> 
  </tr> 
 </tbody> 
</table>

import java.util.ArrayList;
    import java.util.Collection;
    
    /**
     * @author Mr.乐
     * @Description
     */
    public class Collection_01 {
        public static void main(String[] args) {
            //父类的引用指向子类的对象，形成多态
            Collection<String> con = new ArrayList<>();
    
            //追加的方式添加元素
            con.add("东邪");
            con.add("西毒");
            con.add("南帝");
            con.add("北丐");
            con.add("中神通");
    
            //删除,通过元素名称删除元素
            System.out.println(con.remove("西毒"));
            //判断集合中是否包含指定参数元素
            System.out.println(con.contains("西毒"));  //false
            System.out.println(con.contains("东邪"));    //true
            //获取集合中元素个数
            System.out.println(con.size());
            //判断是否为空
            System.out.println(con.isEmpty());//false
            //清空集合
            con.clear();
            //判断是否为空
            System.out.println(con.isEmpty());//true
            System.out.println(con);//打印集合的元素
        }
    }

### 3.3 - Collection集合的遍历 ###

以下迭代方式，是所有Collection通用的一种方式。在Map集合中不能使用，在所有的Collection以及子类中使用。

![26b76cbf738e4269a33a5ac417cd2113.png][]

![897cfae09c564d29824d231577c79b71.png][]

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @author Mr.乐
     * @Description  Collection 集合的遍历
     */
    public class Connection_02 {
        public static void main(String[] args) {
            //多态
            Collection<String> con = new ArrayList<>();
            //添加元素
            con.add("abc");
            con.add("def");
            con.add("100");
            con.add("444");
    
            //Collection集合的遍历方式
            //因为没有索引的概念，所以Collection集合不能使用fori进行遍历
    
            //增强版for循环，其实底层使用的也是迭代器，在字节码文件中查看
            for (String str : con) {
                System.out.print(str + "\t");
            }
            System.out.println();//换行
    
            //迭代器，集合专属的遍历工具
            Iterator<String> it = con.iterator();//创建迭代器对象
            while (it.hasNext()){//判断下一个位置是否有元素
                System.out.print(it.next() + "\t");//获取到下一个位置的元素
            }
        }
    }

### 3.4 - Iterator的remove ###

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * @author Mr.乐
     * @Description
     */
    public class Connection_remove {
        public static void main(String[] args) {
            // 创建集合
            Collection c = new ArrayList();
    
            // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。
            // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。
            // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException
            Iterator it = c.iterator();
    
            // 添加元素
            c.add(1); // Integer类型
            c.add(2);
            c.add(3);
    
            // 获取迭代器
            //Iterator it = c.iterator();
            /*while(it.hasNext()){
                // 编写代码时next()方法返回值类型必须是Object。
                // Integer i = it.next();
                Object obj = it.next();
                System.out.println(obj);
            }*/
    
            Collection c2 = new ArrayList();
            c2.add("abc");
            c2.add("def");
            c2.add("xyz");
    
            Iterator it2 = c2.iterator();
            while(it2.hasNext()){
                Object o = it2.next();
                // 删除元素
                // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
                // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException
                // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）
                //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）
                // 使用迭代器来删除可以吗？
                // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。
                it2.remove(); // 删除的一定是迭代器指向的当前元素。
                System.out.println(o);
            }
    
            System.out.println(c2.size()); //0
        }
    }

## 4 -List ##

`原型ArrayList<E>`

*  ArrayList是一个List接口的实现类，底层使用的是一个可以调整大小的数组实现的。
 *  `<E>`:是一种特殊的数据类型（引用数据类型） -- 泛型
    
     *  ArrayList<String> 或者 ArrayList<Integer> 或者 ArrayList<Student>

### 4.1 - ArrayList构造和添加方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public ArrayList&lt;E&gt;()</code></td> 
   <td>创建一个空集合</td> 
  </tr> 
  <tr> 
   <td><code>public boolean add(E e)</code></td> 
   <td>将指定的参数元素追加到集合的末尾</td> 
  </tr> 
  <tr> 
   <td><code>public void add(int index ,E e)</code></td> 
   <td>在集合的指定位置添加指定的元素（插入元素）</td> 
  </tr> 
  <tr> 
   <td><code>public void addAll(E object)</code></td> 
   <td>用于将指定集合中所有元素添加到当前集合中</td> 
  </tr> 
 </tbody> 
</table>

/**
     * @author Mr.乐
     * @Description  ArrayList构造和添加方法
     */
    public class ArrayList_01 {
        public static void main(String[] args) {
            //创建空集合
            ArrayList<String> list = new ArrayList<>();//泛型定义为String
            //采用默认追加的方式添加元素
            System.out.println(list.add("刘德华"));
            System.out.println(list.add("张学友"));
            System.out.println(list.add("郭富城"));
            System.out.println(list.add("黎明"));
    
            //插入的方式添加元素
    //        list.add(10,"谭咏麟");//插入元素方法索引值不能大于集合中元素个数
    //        list.add(4,"谭咏麟");//表示在集合中最后位置插入元素，与追加相同
            list.add(1,"谭咏麟");//指定位置插入元素，索引位置之后的元素会自动向后进行移动
    
            ArrayList<String> newList = new ArrayList<>();//创建新的集合
            newList.add("小沈阳");
            newList.add("宋小宝");
            newList.add("赵四");
            newList.add("刘能");
    
            //查看集合中的元素
            System.out.println("原集合内部元素：" + list);
            System.out.println("新集合内部元素：" + newList);
    
            list.addAll(newList); //将新集合全部元素添加到原集合中
            System.out.println("原集合内部元素：" + list);
        }
    }

### 4.2 - ArrayList集合常用方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>public boolean remove(Object o)</code></td> 
   <td>删除指定的元素，成功则返回true</td> 
  </tr> 
  <tr> 
   <td><code>public E remove(int index)</code></td> 
   <td>删除指定索引位置的元素，返回被删除的元素</td> 
  </tr> 
  <tr> 
   <td><code>public E set(int index,E e)</code></td> 
   <td>修改指定索引位置的元素，返回修改前的元素</td> 
  </tr> 
  <tr> 
   <td><code>public E get(int index)</code></td> 
   <td>获取指定索引对应的元素</td> 
  </tr> 
  <tr> 
   <td><code>public int size()</code></td> 
   <td>获取结合中元素个数</td> 
  </tr> 
 </tbody> 
</table>

import java.util.ArrayList;
    import java.util.Iterator;
    
    /**
     * @author Mr.乐
     * @Description   ArrayList集合常用方法
     */
    public class ArrayList_02 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
    
            //追加方式添加元素
            list.add("东邪");
            list.add("西毒");
            list.add("南帝");
            list.add("北丐");
            list.add("中神通");
    
            //删除
            System.out.println(list.remove("西毒"));//通过元素名称删除，返回boolean
            System.out.println(list.remove(1));//通过索引删除元素，返回被删除元素名
            //修改
            System.out.println(list.set(1,"西毒"));//指定索引位置修改元素，并返回被修改元素
    
            System.out.println("原集合中元素有：" + list);
            //获取方法
            System.out.println(list.get(1));//通过指定索引位置获取集合元素
            //获取集合元素个数
            System.out.println(list.size());
    
            //集合的遍历,普通for循环
            for (int i = 0; i < list.size(); i++) {
                System.out.print(list.get(i) + "\t");
            }
            System.out.println();
    
            //增强版for循环
            for (String name : list) {
                System.out.print(name+ "\t");
            }
            System.out.println();
    
            //迭代器
            Iterator<String> it = list.iterator();//创建迭代器
            while (it.hasNext()){//判断下一个位置是否有元素
                System.out.print(it.next() + "\t");  //next方法表示获取下一个位置的元素
            }
            System.out.println();
    
            //Stream流
            list.stream().forEach(System.out::println);
        }
    }

### 4.3 -ArrayList实现原理 ###

#### **底层代码：** ####

**属性：**

>     DEFAULT_CAPACITY = 10 默认长度，初始化容量为10
>     
>     Object[] EMPTY_ELEMENTDATA = {} //有参构造所创建
>     
>     Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {} //无参构造所创建的
>     
>     Object[] elementData;底层为Object类型的数组，存储的元素都在此。
>     
>     int size 实际存放的个数

**构造方法 ：**

//一个参数的构造
    public ArrayList(int initialCapacity) {
            if (initialCapacity > 0) {
                this.elementData = new Object[initialCapacity];
            } else if (initialCapacity == 0) {
                this.elementData = EMPTY_ELEMENTDATA;
            } else {
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            }
        }
    //参数如果大于零，则为创建数组的长度；
    //参数如果等于零，EMPTY_ELEMENTDATA；
    //参数如果小于0，抛出异常。
    
    
    //无参构造
      public ArrayList() {
            this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
        }
    //DEFAULTCAPACITY_EMPTY_ELEMENTDATA  new对象时默认为0 当添加第一个元素的时候，数组扩容至10

**add方法源码：（jdk1.8与之不同，此处为jdk16）**

//源码
    public boolean add(E e) {
            modCount++;//操作次数
            add(e, elementData, size);
    //e 操作对象;  elementData 底层操作的数组;size 默认大小0
            return true;
        }
    ------------------------------------------------
     private void add(E e, Object[] elementData, int s) {
            if (s == elementData.length)//ture
                elementData = grow();
            elementData[s] = e;  //存数据
            size = s + 1; //最小需要长度
        }
    ----------------------------------------------------------
     private Object[] grow() {
            return grow(size + 1);
        }
    -----------------------------------------------------
     private Object[] grow(int minCapacity) { //初始传入为size+1  为1
            int oldCapacity = elementData.length; //初始为0
            if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
           //if条件为初始数组长度>0或者数组不是无参构造构建的
                int newCapacity = ArraysSupport.newLength(oldCapacity, //旧数组的长度
                        minCapacity - oldCapacity, /* minimum growth */  
                        //最小需要长度-旧数组的长度  大于0代表空间不足
                        oldCapacity >> 1           /* preferred growth */);
                       //二进制位右移1位  位旧数组长度/2
                return elementData = Arrays.copyOf(elementData, newCapacity);
                将数据放入新数组中
            } else {
                return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
                //数组长度  DEFAULT_CAPACITY为10  此处代表无参构造默认长度为10
            }
        }
    ----------------------------------------------------
     public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
            // assert oldLength >= 0
            // assert minGrowth > 0
              
            int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
             //如果prefGrowth>minGrowth  扩容1.5倍    minGrowth>prefGrowth为需要多少给多少
            if (newLength - MAX_ARRAY_LENGTH <= 0) {
         //MAX_ARRAY_LENGTH为int最大值   表示新数组长度如果小于int的最大值
                return newLength;
            }
            return hugeLength(oldLength, minGrowth);
             //返回int最大值
        }

>     ArrayList集合底层是数组，怎么优化？
>             尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合 的时候预估计元素的个数，给定一个初始化容量。
>     
>     数组优点：
>         检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址，
>         然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。）
>     
>     数组缺点：
>         随机增删元素效率比较低。
>         另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）
>     
>     向数组末尾添加元素，效率很高，不受影响。

## 4.4 -**LinkedList**实现原理 ##

**底层代码**

**属性：**

transient int size = 0;//初始长度
    
        transient Node<E> first;//头节点
    
        transient Node<E> last;//尾节点

**add方法源码：（jdk1.8与之不同，此处为jdk16）**

public boolean add(E e) {
            linkLast(e);
            return true;
        }
    --------------------------------------
    void linkLast(E e) {
            final Node<E> l = last; //初始为null
            final Node<E> newNode = new Node<>(l, e, null);
        //参数1：位上一个节点的内存地址,参数2：e为插入的数据,参数3：下一个节点的内存地址
            last = newNode; // 最后节点为新节点
            if (l == null)  //如果newNode的前一个节点为null,则将新节点赋给first
                first = newNode;
            else
                l.next = newNode;  //尾节点下一个节点为新节点
            size++;//大小
            modCount++;//操作数
        }

### **4.5 -LinkedList和ArrayList**  ###

>  LinkedList和ArrayList方法一样，只是底层实现不一样。ArrayList底层为数组存储，LinkedList是以双向链表存储。LinkedList集合没有初始化容量。最初这个链表中没有任何元素。first和last引用都是null。
> 
>     链表的优点：
>         由于链表上的元素在空间存储上内存地址不连续。
>         所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。
>         在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议
>         使用LinkedList。
>     
>     链表的缺点：
>         不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头
>         节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率
>         较低。
>     
>         ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。）
>         LinkedList：把随机增删发挥到极致。
>         加元素都是往末尾添加，所以ArrayList用的比LinkedList多。

## 4.6 -Vector ##

>     1、底层也是一个数组。
>     2、初始化容量：10
>     3、怎么扩容的？
>         扩容之后是原容量的2倍。
>         10--> 20 --> 40 --> 80
>     4、Vector中所有的方法都是线程同步的，都带有synchronized关键字，
>     是线程安全的。效率比较低，使用较少了。
>     5、怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？
>         使用集合工具类：
>             java.util.Collections;
>             java.util.Collection 是集合接口。
>             java.util.Collections 是集合工具类。
>     Collections.synchronizedList();//将及格转换为线程安全的。

## 5 -Set ##

### 5.1 -概述 ###

*  Set集合也是一个接口，继承自Collection，与List类似，都需要通过实现类来进行操作。
 *  特点
    
     *  不允许包含重复的值
     *  没有索引（就不能使用普通的for循环进行遍历）

import java.util.HashSet;
    import java.util.Set;
    
    /**
     * @author Mr.乐
     * @Description Set集合
     */
    public class Demo01 {
        public static void main(String[] args) {
            //使用多态，父类的引用指向子类对象
            Set<String> set = new HashSet<>();
    
            //添加元素
            set.add("黄固");
            set.add("欧阳锋");
            set.add("段智兴");
            set.add("洪七公");
            set.add("段智兴");
            System.out.println(set);//打印集合
             //[洪七公, 黄固, 欧阳锋, 段智兴]
            //HashSet集合对于元素的读写顺序不做保证
            //相同的元素，多次存储，只能保留一个，并且不会报错
            //List集合可以存储重复元素，Set集合不行
        }
    }

**例：双色球**

import java.util.Random;
    import java.util.TreeSet;
    
    /**
     * @author Mr.乐
     * @Description  双色球 -Set版
     */
    public class Demo02 {
        public static void main(String[] args) {
            Random ran = new Random();//创建随机类对象
    
            int blueBall = ran.nextInt(16) + 1;
    //        HashSet<Integer> redBalls = new HashSet<>();//创建集合用来存储红球
            TreeSet<Object> redBalls = new TreeSet<>();//TreeSet集合自带排序规则
    
            while (redBalls.size() < 6){
                redBalls.add(ran.nextInt(33) + 1);//将当前生成的红球直接存进集合中
                //因为Set集合不能存储重复的元素，所以去重的操作可以省略不做。
            }
            System.out.println("红球：" + redBalls + "篮球 [" + blueBall + "]");
        }
    }

### 5.2 -哈希值 ###

Set集合的去重原理使用的是哈希值。

> 哈希值就是JDK根据对象地址 或者 字符串 或者数值 通过自己内部的计算出来的一个整数类型数据

> `public int hashCode()` \- 用来获取哈希值，来自于Object顶层类
> 
>  *  对象的哈希值特点
>     
>      *  同一个对象多次调用`hashCode()`方法，得到的结果是相同的。
>      *  默认情况下，不同的对象的哈希值也是不同的（特殊情况除外）

/**
     * @author Mr.乐
     * @Description  哈希值
     */
    public class Demo03 {
        public static void main(String[] args) {
            //相同对象哈希值相同
            System.out.println("张三".hashCode());//774889
            System.out.println("张三".hashCode());//774889
    
            //不同对象哈希值不同
            System.out.println(new Object().hashCode());
            System.out.println(new Object().hashCode());
    
            //不同的对象的哈希值也有可能相同，例外情况
            System.out.println("辂鹅".hashCode());//1179395
            System.out.println("较鸦".hashCode());//1179395
            System.out.println("辄鸇".hashCode());//1179395
            System.out.println("辅鷨".hashCode());//1179395
        }
    }

### 5.3 -HashSet去重原理 ###

*  HashSet集合的特点
    
     *  底层结构是“哈希表”
     *  集合对于读写顺序不做保证
     *  没有索引
     *  Set集合中的内容不能重复

/**
     * @author Mr.乐
     * @Description  HashSet去重原理
     */
    public class Demo04 {
        public static void main(String[] args) {
            HashSet<Student> set = new HashSet<>();
            //添加元素
            set.add(new Student("黄固",28));
            set.add(new Student("欧阳锋",38));
            set.add(new Student("段智兴",48));
            set.add(new Student("洪七公",40));
            set.add(new Student("段智兴",48));
            //从程序的角度来考虑，两个段智兴不是同一个对象，都有自己的存储空间，所以哈希值也不一样。
            for (Student stu : set) {
                System.out.println(stu);
            }
            /*
            重写hashcode和equals
            Student{name='段智兴', age=48}
            Student{name='欧阳锋', age=38}
            Student{name='洪七公', age=40}
            Student{name='黄固', age=28}
             */
        }
    }

### 5.4 -LinkedHashSet ###

*  特点
    
     *  LinkedHashSet是哈希表和链表实现的Set接口，具有可预测的读写顺序。
     *  有链表来保证元素有序
     *  有哈希表来保证元素的唯一性

/**
     * @author Mr.乐
     * @Description LinkedHashSet
     */
    public class Demo05 {
        public static void main(String[] args) {
            LinkedHashSet<String> set = new LinkedHashSet<>();
    
            //添加元素
            set.add("黄固");
            set.add("欧阳锋");
            set.add("段智兴");
            set.add("洪七公");
            set.add("段智兴");//重复的元素不能存进去
    
            System.out.println(set);//打印集合 [黄固, 欧阳锋, 段智兴, 洪七公]
        }
    }

### 5.5 -TreeSet ###

> 1、TreeSet集合底层实际上是一个TreeMap
> 
> 2、TreeMap集合底层是一个二叉树。
> 
> 3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
> 
> 4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。

import java.util.TreeSet;
    public class TreeSetTest02 {
        public static void main(String[] args) {
            // 创建一个TreeSet集合
            TreeSet<String> ts = new TreeSet<>();
            // 添加String
            ts.add("zhangsan");
            ts.add("lisi");
            ts.add("wangwu");
            ts.add("zhangsi");
            ts.add("wangliu");
            // 遍历
            for(String s : ts){
                // 按照字典顺序，升序！
                System.out.println(s);
    
            }
            /*
            lisi
             wangliu
             wangwu
             zhangsan
             zhangsi
             */
            TreeSet<Integer> ts2 = new TreeSet<>();
            ts2.add(100);
            ts2.add(200);
            ts2.add(900);
            ts2.add(800);
            ts2.add(600);
            ts2.add(10);
            for(Integer elt : ts2){
                // 升序！
                System.out.println(elt);
            }
        }
    }

#### 5.5.1 -自定义排序规则 ####

> 对于自定义的类无法排序，因为类中对象之间没有比较规则，不知道谁大谁小。

/**
     * @author Mr.乐
     * @Description  自定义比较器
     */
    import java.util.TreeSet;
    
    public class TreeSetTest04 {
        public static void main(String[] args) {
            Customer c1 = new Customer(32);
            Customer c2 = new Customer(20);
            Customer c3 = new Customer(30);
            Customer c4 = new Customer(25);
    
            // 创建TreeSet集合
            TreeSet<Customer> customers = new TreeSet<>();
            // 添加元素
            customers.add(c1);
            customers.add(c2);
            customers.add(c3);
            customers.add(c4);
    
            // 遍历
            for (Customer c : customers){
                System.out.println(c);
            }
        }
    }
    
    // 放在TreeSet集合中的元素需要实现java.lang.Comparable接口。
    // 并且实现compareTo方法。equals可以不写。
    class Customer implements Comparable<Customer>{
    
        int age;
        public Customer(int age){
            this.age = age;
        }
        // 需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！
        // k.compareTo(t.key)
        // 拿着参数k和集合中的每一个k进行比较，返回值可能是>0 <0 =0
        // 比较规则最终还是由程序员指定的：例如按照年龄升序。或者按照年龄降序。
        @Override
        public int compareTo(Customer c) { // c1.compareTo(c2);
            return c.age - this.age;
        }
    
        public String toString(){
            return "Customer[age="+age+"]";
        }
    }

**匿名内部类方式**

public class TreeSetTest05 {
        public static void main(String[] args) {
    //        TreeSet<Student> ts = new TreeSet<>();//默认排序规则
            TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
                @Override
                public int compare(Student o1, Student o2) {
                    int res = o1.getAge() - o2.getAge();
                    return 0 == res ? o1.getName().compareTo(o2.getName()) : res;
                     //三目运算符  等于零用姓名排序
                }
            });//默认排序规则
    
            //添加元素
            ts.add(new Student("Andy",19));
            ts.add(new Student("Jack",18));
            ts.add(new Student("Tom",21));
            ts.add(new Student("Lucy",17));
            ts.add(new Student("Bob",21)); //当年龄相同时，按照姓名的字典顺序排序
    
            for (Student stu : ts) {
                System.out.println(stu);
            }
        }
    }

>     Comparable和Comparator怎么选择呢？
>         当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
>         如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。

## 6 -Map ##

### 6.1 -概述 ###

> 双列集合：用来存储键值对的集合。
> 
>  *  `interface Map<K,V>` : K(key)键 ，V(value)值
>  *  将键映射到值的对象，不能出现重复的键，每个键最多可以映射到一个值

>     1、Map和Collection没有继承关系。
>     2、Map集合以key和value的方式存储数据：键值对
>         key和value都是引用数据类型。
>         key和value都是存储对象的内存地址。
>         key起到主导的地位，value是key的一个附属品。

例子：

<table> 
 <thead> 
  <tr> 
   <th>学号（Key）</th> 
   <th>姓名(Value)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>STU001</td> 
   <td>张三</td> 
  </tr> 
  <tr> 
   <td>STU002</td> 
   <td>李四</td> 
  </tr> 
  <tr> 
   <td>STU003</td> 
   <td>张三</td> 
  </tr> 
 </tbody> 
</table>

### 6.2 -Map的基本方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>V put(K key,V value)</code></td> 
   <td>设置键值对</td> 
  </tr> 
  <tr> 
   <td><code>V remove(Object key)</code></td> 
   <td>删除元素</td> 
  </tr> 
  <tr> 
   <td><code>void clear()</code></td> 
   <td>清空集合</td> 
  </tr> 
  <tr> 
   <td><code>boolean containsKey(Object key)</code></td> 
   <td>判断键是否存在，存在则返回true</td> 
  </tr> 
  <tr> 
   <td><code>boolean containsValue(Object value)</code></td> 
   <td>判断值是否存在，存在则返回true</td> 
  </tr> 
  <tr> 
   <td><code>boolean isEmpty()</code></td> 
   <td>判断集合是否为空</td> 
  </tr> 
  <tr> 
   <td><code>int size()</code></td> 
   <td>获取集合元素个数</td> 
  </tr> 
 </tbody> 
</table>

import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author Mr.乐
     * @Description  集合的基本方法
     */
    public class Map01 {
        public static void main(String[] args) {
            Map<String,String> map = new HashMap<>();
    
            map.put("STU001","Andy");
            map.put("STU002","Jack");
            map.put("STU003","Tom");
            map.put("STU004","Bob");
            map.put("STU004","Smith");//设置（修改）
            //如果键不存在，则表示添加元素。如果键存在，则表示设置值。
    
            //删除
            System.out.println(map.remove("STU003"));  //Tom
            //判断是否包含
            System.out.println(map.containsKey("STU003"));  //false
            System.out.println(map.containsKey("STU004"));  //true
            System.out.println("-----------------------");
            System.out.println(map.containsValue("Tom"));  //false
            System.out.println(map.containsValue("Smith")); //true
    
            System.out.println("-----------------------");
            System.out.println(map.isEmpty());//判断集合是否为空   false
            map.clear();//清空集合
            System.out.println(map.isEmpty()); //true
    
            System.out.println(map); //{}
    
        }
    }

### 6.3 -Map集合的获取功能 ###

import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @author Mr.乐
     * @Description
     */
    public class map_get {
        public static void main(String[] args) {
            Map<String,String> map = new HashMap<>();
    
            map.put("STU001","Andy");
            map.put("STU002","Jack");
            map.put("STU003","Tom");
            map.put("STU004","Bob");
    
            //get通过键获取值
            System.out.println(map.get("STU003"));
            System.out.println("------------------");
            //keySet 获取所有键的Set集合
            Set<String> keySet = map.keySet();
            System.out.println(keySet);
            //values  获取所有值的Collection集合
            Collection<String> values = map.values();
            System.out.println(values);
            //entrySet  获取所有键值对对象的Set集合
            Set<Map.Entry<String, String>> es = map.entrySet();
            //Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V>
            //Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类
            System.out.println(es);
             //[STU001=Andy, STU003=Tom, STU002=Jack, STU004=Bob]
             for (Map.Entry<String, String> entry:es){
                 System.out.println("key:"+entry.getKey()+"    "+"value:"+entry.getValue());
             }
            /*
            key:STU001    value:Andy
            key:STU003    value:Tom
            key:STU002    value:Jack
            key:STU004    value:Bob
             */
        }
    }

### 6.4 -哈希表 ###

> 通过 数组 + 链表 实现的一种数据结构

> 哈希表的构造方法的参数是一个长度为16个元素的数组，通过哈希值 % 16 的值，作为头节点在数组中选择对应的位置，就形成了哈希表。

![a8e00ce4205c4456a021997b4b3a4a52.png][] 注：图转自动力节点。

### 6.5 -HashMap ###

#### 6.5.1 -底层源码 ####

public class HashMap{
                // HashMap底层实际上就是一个数组。（一维数组）
                Node<K,V>[] table;
                // 静态的内部类HashMap.Node
                static class Node<K,V> {
                    final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）
                    final K key; // 存储到Map集合中的那个key
                    V value; // 存储到Map集合中的那个value
                    Node<K,V> next; // 下一个节点的内存地址。
                }
            }

#### 6.5.2 -特点 ####

>     1、无序，不可重复。
>         为什么无序？ 因为不一定挂到哪个单向链表上。
>         不可重复是怎么保证的？ equals方法来保证HashMap集合的key不可重复。
>         如果key重复了，value会覆盖。
>     
>     2、放在HashMap集合key部分的元素其实就是放到HashSet集合中了。
>         所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
> 
>     3、HashMap集合的默认初始化容量是16，默认加载因子是0.75
>         这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组以二叉树开始扩容。
>     
>         重点，记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的，
>         这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。

#### **6.5.3 -注意** ####

> 1.向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！
> 
> equals方法有可能调用，也有可能不调用。
> 
> 拿put(k,v)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。 拿get(k)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。
> 
> 4.假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了 纯单向链表。
> 
> 这种情况我们成为：散列分布不均匀。
> 
> 什么是散列分布均匀？
> 
> 假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的， 是散列分布均匀的。假设将所有的hashCode()方法返回值都设定为不一样的值，可以吗，有什么问题？ 不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。 也是散列分布不均匀。散列分布均匀需要你重写hashCode()方法时有一定的技巧。

## 7 -Properties ##

> Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。 Properties被称为属性类对象。 Properties是线程安全的。

### 7.1 -方法 ###

import java.io.IOException;
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * @author Mr.乐
     * @Description Properties特有方法
     */
    public class Properties01 {
        public static void main(String[] args) throws IOException {
            Properties prop = new Properties();
            final String SRC = "./myConf.ini";//定义配置信息存储路径
    //        mySave(prop,SRC);//存储配置文件
            myLoad(prop,SRC);//加载配置文件信息
            //PASSWORD<--->123456
            //DATABASE<--->YX2115
            //PORT<--->3306
            //USERNAME<--->root
        }
    
        private static void myLoad(Properties prop, String src) throws IOException {
            FileReader fr = new FileReader(src);
            prop.load(fr);//通过流，加载指定路径的配置文件
            fr.close();
            //遍历
            Set<String> keySet = prop.stringPropertyNames();//获取对象键的Set集合
            for (String key : keySet) {
                System.out.println(key + "<--->" + prop.getProperty(key));//通过键拿到值
            }
        }
    
        private static void mySave(Properties prop, String src) throws IOException {
            //将配置信息存储到对象中
            prop.setProperty("USERNAME","root");
            prop.setProperty("PASSWORD","123456");
            prop.setProperty("DATABASE","YX2115");
            prop.setProperty("PORT","3306");
            //写入文件
            FileWriter fw = new FileWriter(src);//创建输出流对象
            prop.store(fw,"MyDataBase Configure!~");
            fw.close();
        }
    }

## 8 -总结 ##

本篇文章介绍了集合的常用方法以及个别集合的底层是如何实现的。介绍了集合的继承与实现结构。各个集合的扩容方式及扩容大小以及各个集合的优点和用途。希望大家可以根据本篇文章可以更加深刻的理解java中的集合。

![0a1b1c280aca421e9fbfda8d57494c75.jpeg][]

[7365658cde9840a5aa4cf2dcc0de115b.png]: https://img-blog.csdnimg.cn/7365658cde9840a5aa4cf2dcc0de115b.png
[d64de167f8ec4e32b9a03b28995e3c7e.png]: https://img-blog.csdnimg.cn/d64de167f8ec4e32b9a03b28995e3c7e.png
[26b76cbf738e4269a33a5ac417cd2113.png]: https://img-blog.csdnimg.cn/26b76cbf738e4269a33a5ac417cd2113.png
[897cfae09c564d29824d231577c79b71.png]: https://img-blog.csdnimg.cn/897cfae09c564d29824d231577c79b71.png
[a8e00ce4205c4456a021997b4b3a4a52.png]: https://img-blog.csdnimg.cn/a8e00ce4205c4456a021997b4b3a4a52.png
[0a1b1c280aca421e9fbfda8d57494c75.jpeg]: https://img-blog.csdnimg.cn/0a1b1c280aca421e9fbfda8d57494c75.jpeg