Java集合框架

Java集合

集合的基本框架

单列集合Collection

双列集合Map

package com.集合;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class Collection_ {
    public static void main(String[] args) {
        //Collection 接口有两个重要的子接口 List Set,他们的实现子类都是单列集合
        List list = new ArrayList();
        list.add("jack");
        list.add(true);

        //Map 接口的实现子类 是双列集合，存放的是 Key-Value
        HashMap hashMap = new HashMap();
        hashMap.put("No1","北京");
        hashMap.put("No2","上海");
    }
}

Collection接口和常用方法

• Collection实现子类可以存放多个元素，每个元素可以是Object
• 有些Collection的实现类，可以存放重复的元素，有些不可以
• 有些Collection的实现类，有些是有序的（List），有些不是有序的（Set）
• Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

Collection接口常用方法

以实现子类ArrayList来演示

package com.集合.collection;

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

public class CollectionMethod {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        List list = new ArrayList();
        // add:添加单个元素
        list.add("jack");//list.add其实是添加了一个个对象，不再是一个个字符串，数字的基本数据类型了
        list.add(10);//相当于是list.add(new Integer(10))
        list.add(true);
        System.out.println("list="+list);

        // remove：删除指定元素
        list.remove(0);//通过下标，删除第一个元素
        list.remove(true);//删除指定元素
        System.out.println("list"+list);

        // contains:查找指定元素是否存在
        System.out.println(list.contains("jack~"));

        // size：获取元素个数
        System.out.println(list.size());

        // isEmpty:判断是否为空
        System.out.println(list.isEmpty());

        // clear: 清空
        list.clear();

        // addAll:添加多个元素 只要是实现了Collection的对象都可以作为参数传入
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list"+list);

        // containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));

        // removeAll:删除多个元素
        list.add("西游记");
        list.removeAll(list2);
        System.out.println("list"+list);
        
    }
}

Collection接口遍历元素方式1——使用Iterator(迭代器)

• Iterator对象称为迭代器，主要用于遍历Collection集合中的元素（Iterator在Collection的父类Iterable类中）

• 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器

• Iterator的结构
  

• Iterator仅用于遍历集合，Iterator本身并不存放对象

package com.集合.collection;

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

public class CollectionIterator {
    @SuppressWarnings("ALL")
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));

        //遍历col集合
        //1.先得到 col对应的迭代器
        Iterator iterator = col.iterator();
        //2.使用while循环遍历
        while (iterator.hasNext()){ //判断是否还有数据
            Object obj = iterator.next();//返回下一个元素，类型是Object
            System.out.println("obj="+obj);
        }
        //快速生成 迭代器的while结构 => 使用快捷键 itit
        //显示所有的快捷键的 快捷键是 ctrl + j

        //3.当退出这个while循环后，这时iterator迭代器，指向最后的元素
        //调用 iterator.next() 会报 NoSuchElementException的异常
        //4.如果希望再次遍历，需要重置我们的迭代器
        iterator = col.iterator();

    }
}
class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }
}

Collection接口遍历元素方式2——增强for循环

package com.集合.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionFor {
    @SuppressWarnings("all")
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));

        for (Object book : col) { //快捷键 iter 或者 I
            System.out.println("book="+book);
        }
        //增强for循环，既可以用于数组，也可以用于Collection集合
        //增强for循环的底层，仍是迭代器，可下断点调试发现
    }
}

List接口方法和常用方法

List接口基本介绍

• List接口是Collection接口的子接口
• List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
• List集合中的每个元素都有其对应的顺序索引，即支持索引
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
• JDK API中List接口的实现类不止：ArrayList、LinkedList和Vector，这几个是常用的

package com.集合.list_;

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

public class List_ {
    @SuppressWarnings("ALL")
    public static void main(String[] args) {
        //1.List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("jack");
        System.out.println("list="+list);//list=[jack, tom, mary, jack]

        //2.List集合中的每个元素都有其对应的顺序索引，即支持索引
        //索引是从0开始的
        System.out.println(list.get(3));//jack
    }
}

List接口方法

package com.集合.list_;

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

public class ListMethod {
    public static void main(String[] args) {
        List list = new ArrayList();//将ArrayList()换为 LinkedList/Vector,这些方法都是通用的
        list.add("张三丰");
        list.add("贾宝玉");
        //1.void add(int index, Object element); 在index位置插入ele对象
        //在index = 1的位置插入一个对象
        list.add(1,"刘备");
        System.out.println("list="+list);//list=[张三丰, 刘备, 贾宝玉]

        //2.boolean addAll(int index, Collection c); 从index位置开始将c中的所有对象加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1,list2);
        System.out.println("list="+list);//list=[张三丰, jack, tom, 刘备, 贾宝玉]

        //3.int indexOf(Object obj); 返回obj在集合中第一次出现的位置
        System.out.println(list.indexOf("tom"));//2

        //4.int lastIndexOf(Object obj); 返回obj在集合中最后一次出现的位置
        list.add("tom");
        System.out.println(list.lastIndexOf("tom"));//5

        //5.Object remove(int index); 移除指定index位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list="+list);//list=[jack, tom, 刘备, 贾宝玉, tom]

        //6.Object set(int index, Object element); 设置指定index位置的元素为element，相当于替换
        list.set(1,"玛丽");
        System.out.println("list="+list);//list=[jack, 玛丽, 刘备, 贾宝玉, tom]

        //7.List subList(int fromIndex, int toIndex); 返回从fromIndex到toIndex位置的子集合
        List returnlist = list.subList(0,2);//左闭右开
        System.out.println("returnlist="+returnlist);//returnlist=[jack, 玛丽]
    }
}

List的三种遍历方式

• 方法一：使用iterator
• 方法二：使用增强for循环
• 方法三，使用普通for（前面两种在上面演示过了，我们来看第三种也很简单）

        for (int i = 0; i < list.size(); i++) {
            System.out.println("对象="+list.get(i));
        }

ArrayList底层结构和源码分析

ArrayList注意事项

• ArrayList可以加入多个null值

ArrayList arrayList = new ArrayList();
        arrayList.add(null);
        arrayList.add("jack");
        arrayList.add(null);
        System.out.println(arrayList);//[null, jack, null]

• ArrayList是由数组来实现数据存储的
• ArrayList基本等同于Vector，ArrayList是线程不安全的（源码中的方法并无 synchronized修饰），但是执行效率高，在多线程的情况下，不建议使用ArrayList

ArrayList的底层操作机制源码分析（重点、难点）

• ArrayList中维护了一个Object类型的数组 elementData
  • transient Object[ ] elementData
  • transient (瞬间、短暂的) 表示该属性不会被序列化
• 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加。则扩容elementData为10.如需再次扩容，则扩容成现在elementData容量的1.5倍
• 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容成现在elementData容量的1.5倍

示例：

package com.集合.list_;

import java.util.ArrayList;

@SuppressWarnings("all")
public class ArrayListSource {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();  //无参构造的情况
        //ArrayList arrayList = new ArrayList(8); //有参构造的情况
        for (int i = 1; i <= 10; i++) {
            list.add(i);                 
        }
        for (int i = 11; i <= 15 ; i++) {
            list.add(i);
        }
        list.add(100);
        list.add(200);
        list.add(null);
    }
}

1. 第一步： ArrayList list = new ArrayList();

   无参构造函数:

​ 获得一个空的Object类型的数组：DEFAULTCAPACITY_EMPTY_ELEMENTDATA

2. 第二步：list.add(i);

​ add方法： 先确定是否要扩容，然后再执行赋值

3. 确定elementData的容量：

​

4. 计算elementData的容量：如果elementData是DEFAULTCAPACITY_EMPTY_ELEMENTDATA即新创建出来的，在默认的 DEFAULT_CAPACITY（等于10）与 minCapacity之间返回最大值。

​ 如果elementData不是默认的空数组，直接返回minCapacity

​

5. 判断是否扩容： modCount进行计数当前这个集合被修改的次数，如果有多线程修改这个值，则会抛出异常

​ 这里将 minCapacity 与 elementData的实际长度进行比较，判断是否扩容

​

6. 进行扩容 grow(minCapacity): int newCapacity = oldCapacity + (oldCapacity >> 1); >>1位运算，右移一位

​ (oldCapacity >> 1) 右移一位相当于，oldCapacity除以2，这里实现扩容为原来的1.5倍

​ 扩容使用的是 Arrays.copuOf()

​

有参构造函数的情况：

创建了一个指定大小的elementData数组，在add中elementData就不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，会直接返回minCapacity（这里的minCapacity可以理解为已占的空间+即将需要的1个空间）

Vector底层结构和源码分析

Vector的基本介绍

• Vector类的定义说明

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

• Vector底层也是一个对象数组 protected Object[ ] elementData
• Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
• 在开发中，需要线程同步安全时，考虑使用Vector

Vector和ArrayList的比较

	底层结构	版本	线程安全（同步）效率	扩容倍数
ArrayList	可变数组	jdk1.2	不安全，效率高	如果是无参构造时，1.第一次10，2.第二次开始按1.5倍扩容；如果有参构造不足时扩容1.5倍
Vector	可变数组	jdk1.0	安全，效率不高	如果是无参构造时，1.默认为10，2.第二次开始按2倍扩容；如果有参，不足时按2倍扩容

Vector的底层操作机制源码分析

1. 第一步：无参构造器：

直接调用有参构造器，并指定容量大小为10

2. 第二步：add()方法中，确定是否要扩容

3. ensureCapacityHelper( )

​

4. 判断确实需要扩容了：grow( ) , capacityIncrement这里实现了扩容两倍，capacityIncrement在上面的构造函数中被初始化

   ​

LinkedList底层结构和源码分析

LinkedList的简单介绍

• LinkedList底层实现了双向链表和双端队列特点
• 可以添加任意元素（元素可以重复），包括null
• 线程不安全，没有实现同步

LinkedList的底层操作机制

• LinkedList底层维护了一个双向链表

• LinkedList中维护了两个属性first和last分别指向 首节点和尾节点

• 每个节点（Node对象），里面维护了 prev 、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终实现双向链表

• 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

  1. 第一步：

  无参构造器创建一个空的列表，此时 first为null，last也是null

  2. 执行add方法：

     ​

     ​

• 首先拿到尾节点last赋给 l ，新建一个node节点，将node的前驱节点指向 l ，后驱节点设为null，则此时 last节点 即为新建的node节点

• 此时判断前一个节点 l ，l=null是初始的情况下，会将 first 和 last 都指向新建的node，在第二次及以后的时候则会走else，将前一个节点 l 的next 指向新建的这个节点node，至此形成一个双向链表

3. 因为LinkedList是实现了List接口，在list中提到的 remove删除，set修改，get按索引得到对象，几种遍历方式都可以使用。

LinkedList和ArrayList的比较

	底层结构	增删的效率	改查的效率
ArrayList	可变数组	较低，通过数组扩容	较高
LinkedList	双向链表	较高，通过链表追加	较低

如何选择ArrayList和LinkedList：（LinkedList和ArrayList都是线程不安全的）

1. 如果我们改查的操作多，选择ArrayList
2. 如果我们增删的操作多，选择LinkedList
3. 一般来说，在实际开发中，大部分操作都是查询，因此大部分情况下会选择ArrayList
4. 在一个项目中，根据业务灵活选择，也可能，一个模块使用的是ArrayList，另一个模块是LinkedList。

Collections工具类

工具类方法1

package com.集合.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@SuppressWarnings("ALL")
public class Collections_ {
    public static void main(String[] args) {
        //创建ArrayList集合，用于测试
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");

        //reverse(List):反转List中元素的顺序
        Collections.reverse(list);
        System.out.println(list);//[milan, king, smith, tom]
        //shuffle(List):对List集合元素进行随机排序
        Collections.shuffle(list);//每次排序顺序都不一样
        //sort(List):根据元素的自然排序对指定的List集合元素按升序排列
        Collections.sort(list);
        System.out.println(list);//[king, milan, smith, tom]
        //sort(List,Comparator) 根据指定的Comparator产生的顺序对List集合进行排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o2).length()-((String)o1).length();
            }
        });
        System.out.println(list);//[milan, smith, king, tom]
        //swap(List list,int i,int j):将指定list集合中的i处元素和j处元素进行交换
        Collections.swap(list,0,1);
        System.out.println(list);//[smith, milan, king, tom]
    }
}

工具类方法2

package com.集合.collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@SuppressWarnings("all")
public class Collections2_ {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");

        //Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
        System.out.println("自然排序中的最大元素是"+ Collections.max(list));//自然排序中的最大元素是tom
        //Object max(Collection,Comparator)也可自定义排序方法
        //Object min(Collection)
        //Object min(Collection,Comparator):同上max中的示例

        //int frequency(Collection,Object):返回指定集合中指定元素的出现次数
        System.out.println("tom出现的次数="+Collections.frequency(list,"tom"));//tom出现的次数=2
        //void copy(List dest,List src):将src中的内容复制到dest中
        ArrayList dest = new ArrayList();
        //为了完成一个完整的拷贝，我们需要献给dest赋值，大小和list.size()一样
        for (int i = 0; i < list.size(); i++) {
            dest.add("");
        }
        Collections.copy(dest,list);
        System.out.println("dest="+dest);//dest=[tom, smith, king, milan, tom]

        //boolean replace(List list,Object oldVal,Object newVal):使用新值替换List中所有的旧值
        Collections.replaceAll(list,"tom","汤姆");
        System.out.println(list);//[汤姆, smith, king, milan, 汤姆]
        
    }
}

Set接口和常用方法

• 无序（添加和取出的顺序不一致），没有索引
• 不允许重复元素，所以最多包含一个null
• JDK API中Set接口的实现类不止：HashSet、TreeSet这两个是最常用的

Set接口的常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样

Set接口的遍历方式

同Collection的遍历方式一样（两种），因为Set接口是Collection接口的子接口

1. 可以使用迭代器
2. 增强for循环
3. 不可以使用索引的方式来获取，因为根本就没有索引

HashSet

HashSet的全面说明

• HashSet实现了Set接口

• HashSet实际上是HashMap
  

• HashSet可以存放null值，但是只能有一个null

• HashSet不保证元素是有序的，取决于hash后，再确定索引的结果（不能保证添加和取出的顺序一致）

• 不能有重复元素/对象，在前面Set接口使用已经讲过

package com.集合.set_;

import java.util.HashSet;
@SuppressWarnings("all")
public class HashSet01 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        //HashSet不能添加相同的元素/数据？
        set.add("lucy");//添加成功，在执行add方法后，会返回一个boolean值，添加成功返回true
        set.add("lucy");//添加不了
        set.add(new Dog("tom"));//ok
        set.add(new Dog("tom"));//ok
        System.out.println("set="+set); //set=[Dog{name='tom'}, Dog{name='tom'}, lucy]

        //面试题
        set.add(new String("zmc"));//添加成功
        set.add(new String("zmc"));//加入不了，请看下面分析源码
    }
}
class Dog{
    private String name;

    public Dog(String name) {
        this.name = name;
    }

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

HashSet底层机制说明

HashSet的底层是HashMap，HashMap底层是（数组+链表+红黑树）

模拟数组+链表的结构

package com.集合.set_;

@SuppressWarnings("all")
public class HashSetStructure {
    public static void main(String[] args) {
        //模拟一个HashSet的底层 （HashMap的底层结构） 数组+链表

        //1.创建一个数组，数组的类型是 Node[]
        //2.有些人，直接把Node[]数组称为 表
        Node[] table = new Node[16];
        //3.创建节点
        Node john = new Node("john", null);
        table[2]=john;
        Node jack = new Node("jack",null);
        john.next=jack;
        Node rose = new Node("Rose",null);
        jack.next=rose;
        System.out.println("table="+table);
    }
}
class Node{//结点，存储数据，可以指向下一个节点，从而形成链表
    Object item;//存放数据
    Node next;//指向下一个节点

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }
}

HashSet扩容机制（hash（）+equals（））

1. 添加一个元素的时候，会先得到hash值—> 转成索引值
2. 找到存储数据库表table，看这个索引位置是否已经存放元素
3. 如果没有，直接加入
4. 如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加到最后
5. 在Java8中，如果一条链表的元素个数 >= TREEIFY_THRESHOLD(默认是8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)
6. 如果table数组使用到了临界值12，就会扩容到16*2=32，新的临界值就是32 *0.75=24，依次类推，每次扩容两倍

源码分析：

        HashSet set = new HashSet();
        set.add("java");
        set.add("php");
        set.add("java");

第一步：进入HashSet的构造函数

第二步：执行add( )方法

第三步：进入HashMap的put方法

key的值是传入的"java" value=PRESENT
(PRESENT在HashMap类中，是为了从HashSet转到HashMap，起到占位作用)

第四步：hash( )计算索引值，按位异或

第五步：紧接第三步进入 putVal( )源码

    /**
     * Implements Map.put and related methods.
     *
     * @param hash - hash for key
     * @param key - the key
     * @param value - the value to put
     * @param onlyIfAbsent - if true, don't change existing value
     * @param evict - if false, the table is in creation mode.
     * @Returns previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //table就是 HashMap 的一个数组，类型是 Node[]
        //if语句表示如果当前table是null，或者大小=0
        //tab=resize()就是第一次扩容，到16个空间，可见下面resize()源码
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //（1）根据key的hash值 进行(n - 1) & hash （&的意思是与，两个位都为1时，结果才为1），去计算该key应该存放到table表中的哪一个索引位置
        //并把这个位置的对象，赋给p
        //（2）判断p是否为null
        //（2.1）如果p为null，表示还没有存放元素，就创建一个Node(key="java",value=PRESENT)，并放在tab[i]这个位置
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&//如果当前索引位置对应链表的第一个元素和准备添加的key的hash值一样
                //并且满足下面两个条件之一：
                //准备加入的key和p指向的Node节点的key是同一个对象
                //p指向的Node节点的key的equals()和准备加入的key比较后相同
                //此时就不能加入，对于上面的Dog对象，equals并未重写，两个对象是不一样的，对于String对象，重写了equals方法，比较的是两个字符串是否相等，因此不添加
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //再判断p是不是一颗红黑树，如果是就调用putTreeVal来添加
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//这种情况下，table对应的位置，已经是一个链表，就使用for循环比较
                //(1)依次和该链表的每一个元素依次比较
                //(2)如果有相同的情况，就直接break不添加了，如果没有，加入到链表的最后
                //(3)注意在把元素添加到链表后，立即判断当前这个链表是否已达到8个结点，就调用treeifyBin()当前这个链表进行树化（转成红黑树）
                //注意：在就调用treeifyBin()中还会判断MIN_TREEIFY_CAPACITY,即表的长度有没有达到64，否则会先进行扩容表长，当上述这两个条件都满足时，才会转成红黑树
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //size就是我们每加入一个节点Node(k,v,h,next),size就++
        if (++size > threshold)//threshold是下面resize()第一次进入算出的12，大于这个值会进行扩容，而且注意！！！，扩容时并不是看table表上有12个位置上有12条链表时才会扩容，而是链表上的节点个数，即这里的size大小，达到12个以上就会扩容
            resize();//除第一次初始化，以后都在这里进行真正的扩容
        afterNodeInsertion(evict);//空，HashMap留给子类去实现其他功能
        return null;
    }

    /**
     * Initializes or doubles table size.  If null, allocates in
     * accord with initial capacity target held in field threshold.
     * Otherwise, because we are using power-of-two expansion, the
     * elements from each bin must either stay at same index, or move
     * with a power of two offset in the new table.
     *
     * @Returns the table
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold  这里是扩容了两倍
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;//默认的初始容量16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
            //DEFAULT_LOAD_FACTOR是负载因子为0.75，默认初始容量为16，当容量变为0.75*16=12个时，就会进行扩容，而不是等待			16个位置全被占满了才进行扩容
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

HashSet练习

package com.集合.set_;

import java.util.HashSet;
import java.util.Objects;

@SuppressWarnings("all")
public class HashSetExercise {
    public static void main(String[] args) {
        /*
        * 定义一个Employee类，该类包含:private成员属性name,age要求：
        * 创建3个Employee对象放入HashSet中
        * 当name和age的值相同时，认为是相同员工，不能添加进
        * */
        HashSet set = new HashSet();
        set.add(new Employee("milan",18));//OK
        set.add(new Employee("lucy",20));//OK
        set.add(new Employee("milan",18));//hashcode相同，table索引一致找到同一个链表上，equals比较，发现这个对象的name和age与之前的相同，添加不进去
        System.out.println(set);//[Employee{name='milan', age=18}, Employee{name='lucy', age=20}]
    }
}

class Employee{
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age && Objects.equals(name, employee.name);
    }

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

LinkedHashSet

LinkedHashSet的全面说明

• LinkedHashSet是HashSet的子类
• LinkedHashSet底层是一个LinkedHashMap，底层维护了一个 数组+双链表
• LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使元素看起来是以插入顺序保存的
• LinkedHashSet不允许添加重复的元素

LinkedHashSet底层机制说明

1. 在LinkedHashSet中维护了一个hash表和一个双向链表

2. 每一个节点都有before和after属性，这样可以形成双向链表

3. 在添加一个元素时，先求hash值，再求索引，确定该元素在table中的位置，然后将添加的元素加入到双向链表（如果存在，则不添加）

   	tail.next = newElement
       newElement.pre = tail
       tail = newEelment
   

4. 这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致

源码分析

第一步：LinkedHashSet底层维护的是一个LinkedHashMap（是HashMap的子类）

第二步：添加第一次时，直接将数组table扩容到16，存放的节点类型时 LinkedHashMap$Entry

​ 数组的存放类型是HashMap$Node[]存放的元素/数据是LinkedHashMap$Entry类型

​ 果然 Entry继承于HashMap里的Node类(静态内部类)

第三步:进入add方法:

发现进入还是HashSet的add方法,与上述的HashSet一致,实际上呢又是进入了HashMap的那一套方法中

Map接口和常用方法

这里讲的是JDK8的Map接口特点

• Map和Collection并列存在,用于保存具有映射关系的数据:Key-Value
• Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
• Map中的key不允许重复, 原因和HashSet一样,当有相同的k时,新的value值会替换之前的value值
• Map中的value可以重复
• Map的key可以为null,value也可以是null,注意key为null,只能有一个,value为null可以有多个
• 常用String类作为Map的 key
• key和value之间存在单向一对一的关系,即通过指定的 key总能找到对应的value
• Map存放一对 k-v 是放在一个**HashMap$Node\ast \ast 中的，又因为HashMap$Node实现了Entry接口，有些书上也说 一对 k-v 就是一个Entry

下面具体解释一下上述的最后一点特性：

1.Node是HashMap中的一个静态内部类

2.同时我们发现Node实现了 Map.Entry的接口

3.k-v最后是放在了 HashMap$Node node = newNode(hash, key, value, null) 中

4.k-v为了方便遍历，还会创建EntrySet集合，该集合存放的元素类型为Entry，而一个Entry对象中就有k-v

EntrySet>,即：Set> entrySet

5.实际上是让Set>中的K，指向HashMap$Node中的Key，Set<Map.Entry<K,V>>中的V，指向HashMap$Node中的Value

6.看下面，entrySet(Set<>)中，定义的类型是 Map.Entry，但实际上存放的还是HashMap$Node,因为这里做了一个向上转型，因为HashMap$Node实现了Map.Entry的接口，他们两者是存在关系的，所以实际的运行类型是HashMap$Node

		Map map = new HashMap();
        map.put("no1","zmc");
        map.put("no2","张无忌");

        Set set = map.entrySet();
        System.out.println(set.getClass());//class java.util.HashMap$EntrySet
        for (Object entry : set) {
            System.out.println(entry.getClass());//class java.util.HashMap$Node
        }

7.当把HashMap$Node对象存放到entrySet中，就方便我们的遍历，因为Map.Entry 提供了重要方法 getKey( )与getValue( );

Map接口方式

package com.集合.map_;

import java.util.HashMap;
import java.util.Map;
@SuppressWarnings("all")
public class MapMethod {
    public static void main(String[] args) {
        Map map = new HashMap();
        //put添加
        map.put("邓超","**");
        map.put("邓超","孙俪");
        map.put("王宝强","马蓉");
        map.put("宋喆","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");

        System.out.println("map=" + map);//map={邓超=孙俪, 宋喆=马蓉, 刘令博=null, null=刘亦菲, 王宝强=马蓉, 鹿晗=关晓彤}
        //remove：根据键值删除映射关系
        map.remove("宋喆");
        System.out.println("map="+map);//map={邓超=孙俪, 刘令博=null, null=刘亦菲, 王宝强=马蓉, 鹿晗=关晓彤}
        //get：根据键获取值
        Object val = map.get("鹿晗");
        System.out.println("val="+val);//val=关晓彤
        //size:获取元素个数
        System.out.println("k-v="+map.size());//k-v=5
        //isEmpty:判断个数是否为0
        System.out.println(map.isEmpty());//false
        //clear:清除k-v
        map.clear();
        System.out.println("map="+map);//map={}
        //containsKey:查找键是否存在
        System.out.println("结果="+map.containsKey("王宝强"));//结果=false
    }
}

Map六大遍历方式

package com.集合.map_;

import java.util.*;

@SuppressWarnings("ALL")
public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("邓超","**");
        map.put("邓超","孙俪");
        map.put("王宝强","马蓉");
        map.put("宋喆","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");

        //第一组：先取出所有的Key,通过Key取出对应的Value
        Set keySet = map.keySet();
        //(1)增强for循环
        System.out.println("---取出所有的K-V 增强for---");
        for (Object key : keySet) {
            System.out.println(key+"-"+map.get(key));
        }
        //(2)迭代器
        System.out.println("---取出所有的K-V 迭代器---");
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key+"-"+map.get(key));
        }

        //第二组：把所有的values取出
        Collection values = map.values();
        //这里可以使用所有Collection使用的遍历方法
        //(3)增强for循环
        System.out.println("---取出所有的value 增强for---");
        for (Object value : values) {
            System.out.println(value);
        }
        //(4)迭代器
        System.out.println("---取出所有的value 迭代器---");
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
            Object value =  iterator2.next();
            System.out.println(value);
        }

        //第三组： 通过EntrySet来获取K-V
        Set entrySet = map.entrySet();// EntrySet>
        //(5)增强for循环
        System.out.println("---使用EntrySet的 增强for");
        for (Object entry : entrySet) {
            Map.Entry m =(Map.Entry)entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }
        //(6)迭代器
        System.out.println("---使用EntrySet的 迭代器");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
            Object entry =  iterator3.next();
            System.out.println(entry.getClass());//HashMap$Node 实现 -> Map.Entry (getKey,getValue)
            //向下转型 Map.Entry
            Map.Entry m = (Map.Entry)entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }
    }
}

Map接口练习题

使用HashMap添加3个员工对象，要求 键：员工id 值：员工对象 并遍历显示 工资>18000 的员工

员工类：姓名、工资、员工id

package com.集合.map_;

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

public class MapExercise {
    public static void main(String[] args) {
        Map hashMap = new HashMap();
        hashMap.put(1,new Emp("jack",30000,1));
        hashMap.put(2,new Emp("tom",21000,2));
        hashMap.put(3,new Emp("milan",12000,3));

        //遍历（2种方式）
        //1.使用KeySet -> 增强for
        Set keySetet = hashMap.keySet();
        for (Object key : keySetet) {
            //先获取value
            Emp emp = (Emp) hashMap.get(key);
            if(emp.getSal()>18000){
                System.out.println(emp);
            }
        }
        //2.使用EntrySet -> 迭代器
        Set entrySet = hashMap.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry entry = (Map.Entry)iterator.next();
            Emp emp =(Emp)entry.getValue();
            if(emp.getSal()>18000){
                System.out.println(emp);
            }
        }
    }
}

class Emp{
    private String name;
    private double sal;
    private int id;  

    public Emp(String name, double sal, int id) {
        this.name = name;
        this.sal = sal;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", id=" + id +
                '}';
    }
}

HashMap

HashMap小结

• Map接口的常用实现类：HashMap、Hashtable和Properties
• HashMap是Map接口使用频率最高的实现类
• HashMap是以 key-val 对的方式来存储数据
• key不能重复，但是值可以重复，允许使用null键和null值
• 如果添加相同的key，则会覆盖原来的key-val，等同于修改，key不会被替换，val会替换
• 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的（jdk8的HashMap底层 数组+链表+红黑树）
• HashMap没有实现线程同步，因此线程是不安全的（没有synchronized）

HashMap底层机制及源码剖析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hXet3Ftf-1651137212098)(…/…/source/image-20220428083339499.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-THj92FkG-1651137212099)(…/…/source/image-20220428083613986.png)]

具体内容可以看HashSet的源码分析，HashSet的底层就是HashMap

HashTable

HashTable的基本介绍

• 存放的元素是键值对，即 K-V
• HashTable的键和值都不能为null
• HashTable使用方法基本上和HashMap一样
• HashTable是线程安全的(synchronized)，HashMap是线程不安全的

HashTable的底层及扩容

1. 底层有数组 Hashtable$Entry[ ] 初始化大小为11
2. 临界值 threshold为 8 = 11 * 0.75
3. 在添加的put方法中执行方法 addEntry(hash, key, value, index);
4. 在addEntry方法中，判断count当前的计数是否大于等于临界值，进入rehash( )

5. 在rehash方法中可以看到扩容的大小是原来大小的2倍再+1

HashMap和HashTable的对比

	版本	线程安全（同步）	效率	允许null键null值
HashMap	1.2	不安全	高	可以
HashTable	1.0	安全	低	不可以

Properties

Properties基本介绍

• Properties类继承自HashTable类，并且实现了Map接口，也是使用一种键值对的形式来保存数据
• 他的使用特点和HashTable类似
• Properties还可以用于xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改
• xxx.properties文件通常作为开发中的配置文件

TreeSet

简单介绍

1. 当我们使用无参构造器，创建TreeSet时，value是按自然排序的方法排序的（自然排序可见下面TreeMap中的介绍）
2. 使用TreeSet的Comparator有参构造器，可以传入一个比较器（匿名内部类），并指定排序规则（在Arrays类的介绍中，详细解释了这种定制排序的方法）

package com.集合.set_;

import java.util.Comparator;
import java.util.TreeSet;
@SuppressWarnings("all")
public class TreeSetSource {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //调用String的compareTo方法进行字符串大小比较
                return ((String)o1).compareTo((String)o2);
            }
        });
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("ab");
        System.out.println(treeSet);//[a, ab, jack, sp, tom]
    }
}

源码分析

1.TreeSet的Comparator有参构造器，将传入的比较器对象，赋给了TreeSet的底层的TreeMap的属性

2.在treeSet.add(“jack”);中，进入add方法的底层中是TreeMap中的put方法中：将cpr动态绑定到我们的匿名内部类对象comparator

TreeMap

1.使用元素自然排序（比较的是key）

在使用自然顺序排序时候，需要区分两种情况：一种是Jdk定义的对象，一种是我们应用自己定义的对象；

在自然顺序比较中，需要让被比较的元素实现Comparable接口，否则在向集合里添加元素时报："java.lang.ClassCastException: com.jiaboyan.collection.map.SortedTest cannot be cast to java.lang.Comparable"异常；

这是因为在调用put()方法时，会将传入的元素转化成Comparable类型对象，所以当你传入的元素没有实现Comparable接口时，就无法转换，遍会报错；

2.使用自定义比较器排序（比较的是key）

使用自定义比较器排序，需要在创建TreeMap对象时，将自定义比较器对象传入到TreeMap构造方法中；

自定义比较器对象，需要实现Comparator接口，并实现比较方法compare(T o1,T o2)；

值得一提的是，使用自定义比较器排序的话，被比较的对象无需再实现Comparable接口了；

总结：开发中如何选择集合实现类