集合和Map

集合和Map继承图

集合主要是两组（单列集合，双列集合）
Collection 接口有两个重要的子接口
Map 接口的实现子类是双列集合，存放的K-V

Collection 接口和常用方法

Collection 接口实现类的特点

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

java

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(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"));//T
    
		// size:获取元素个数
		System.out.println(list.size());//2
    
    // isEmpty:判断是否为空
		System.out.println(list.isEmpty());//F
    
		// clear:清空
		list.clear();
		System.out.println("list=" + list);
    
		// addAll:添加多个元素
		ArrayList list2 = new ArrayList();
		list2.add("红楼梦");
		list2.add("三国演义");
		list.addAll(list2);
		System.out.println("list=" + list);
    
		// containsAll:查找多个元素是否都存在
		System.out.println(list.containsAll(list2));//T
    
		// removeAll：删除多个元素
		list.add("聊斋");
		list.removeAll(list2);
		System.out.println("list=" + list);//[聊斋]
		// 说明：以 ArrayList 实现类来演示. 
  }
}

Collection 接口遍历元素方式

使用 Iterator(迭代器)

迭代器基本介绍

Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
Iterator的结构【看下图】
Iterator 仅用于遍历集合，Iterator本身并不存放对象

Iterator接口的方法

hasNext():判断是否还有下一个元素

next()：下移，将下移以后集合上的位置返回

remove

Tip : 在调用iteraotr.next()方法之前，必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用iterator.next()会抛出NoSuchElementException异常

java

Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
//System.out.println("col=" + col);
//现在老师希望能够遍历 col 集合
//1. 先得到 col 对应的 迭代器
Iterator iterator = col.iterator();
//2. 使用 while 循环遍历
// while (iterator.hasNext()) {//判断是否还有数据
// //返回下一个元素，类型是 Object
// Object obj = iterator.next();
// System.out.println("obj=" + obj);
// }
//老师教大家一个快捷键，快速生成 while => itit
//显示所有的快捷键的的快捷键 ctrl + j
while (iterator.hasNext()) {
	Object obj = iterator.next();
	System.out.println("obj=" + obj);
}
//3. 当退出 while 循环后 , 这时 iterator 迭代器，指向最后的元素
// iterator.next();//NoSuchElementException
//4. 如果希望再次遍历，需要重置我们的迭代器
iterator = col.iterator();
System.out.println("===第二次遍历===");
while (iterator.hasNext()) {
	Object obj = iterator.next();
	System.out.println("obj=" + obj);
}

增强for循环遍历

增强for循环，可以代替iterator迭代器，特点：增强for循环就是简化版的iterator，本质一样，只能用于遍历集合或数组

java

for(Object object:col){
	system.out.println(object)
}

List list = new ArrayList();
list.add(new Dog("小黑", 3));
list.add(new Dog("大黄", 100));
list.add(new Dog("大壮", 8));
//先使用 for 增强
for (Object dog : list) {
	System.out.println("dog=" + dog);
}
//使用迭代器
System.out.println("===使用迭代器来遍历===");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
	Object dog = iterator.next();
	System.out.println("dog=" + dog);
}

List接口和常用方法

List 接口基本介绍

List接口是Collection接口的子接口

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

常用方法

java

List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");

// void add(int index, Object ele):在 index 位置插入 ele 元素
//在 index = 1 的位置插入一个对象
list.add(1, "韩顺平");
System.out.println("list=" + list);

// boolean addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1, list2);
System.out.println("list=" + list);

// Object get(int index):获取指定 index 位置的元素
//说过

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

// int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
list.add("韩顺平");
System.out.println("list=" + list);
System.out.println(list.lastIndexOf("韩顺平"));

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

// Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换. list.set(1, "玛丽");
System.out.println("list=" + list);

// List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合// 注意返回的子集合 fromIndex <= subList < toIndex
List returnlist = list.subList(0, 2);
System.out.println("returnlist=" + returnlist);

List 的三种遍历方式

使用iterator

使用增强for

使用普通for

java

// 使用iterator
Iterator iterator = col.iterator()
while(iterator.hasNext()){
	Object o = iterator.next();
	system.out.println(o);
}

// 使用增强for
for(Object o : col){
    system.out.println(o);
}

// 使用普通for
for(int i = 0 ; i < list.size(); i++){
    Object o = list.get(i);
    system.out.println(o);
}

ArrayList 底层结构和源码分析

ArrayList注意事项

ArrayList可以加入null , 并且多个
ArrayList是由数组来实现数据存储的
ArrayList基本等同于Vector，除了ArrayList是线程不安全的（执行效率高）,在多线程情况下，不建议使用ArrayList

ArrayList的底层操作机制

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

Vecotr底层机制和源码剖析

Vector类的定义说明
java
public class Vector<E> 
  extends AbstractList<E> 
  implements List<E>,RandomAccess,Cloneable,Serializeable
1
2
3
Vector底层也是一个对象数组，protected Object[] elementData
Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
java
public synchronized E get(int index){
  if(index > elementCount)
    throw new ArrayIndexOutOfBoundsException(index)
   return elementData(index)
}
1
2
3
4
5
在开发时，需要线程同步时，考虑使用Vector

源码剖析

java

//无参构造器
//有参数的构造
Vector vector = new Vector(8);

//1. new Vector() 底层
/*
public Vector() {
	this(10);
}
补充：如果是 Vector vector = new Vector(8);
走的方法:
public Vector(int initialCapacity) {
	this(initialCapacity, 0);
}
2. vector.add(i)
2.1 //下面这个方法就添加数据到 vector 集合
public synchronized boolean add(E e) {
	modCount++;
	ensureCapacityHelper(elementCount + 1);
	elementData[elementCount++] = e;
	return true;
}
2.2 //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
	if (minCapacity - elementData.length > 0)
		grow(minCapacity);
	}
2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
	//newCapacity = oldCapacity + ((capacityIncrement > 0) ?
	// capacityIncrement : oldCapacity);
	//就是扩容两倍. private void grow(int minCapacity) {
	// overflow-conscious code
	int oldCapacity = elementData.length;
	int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
	if (newCapacity - minCapacity < 0)
		newCapacity = minCapacity;
	if (newCapacity - MAX_ARRAY_SIZE > 0)
		newCapacity = hugeCapacity(minCapacity);
	elementData = Arrays.copyOf(elementData, newCapacity);
}
*/

Vector 和 ArrayList的比较

	底层结构	版本	线程安全（同步）效率	扩容机制
ArrayList	可变数组Object[]	jdk1.2	不安全，效率高	如果有参构造1.5倍如果是无参 1.第一次10 2.从第二次开始按1.5倍扩容
Vector	可变数组Object[]	jdk1.0	安全，效率不高	如果是无参，默认10，满后，就按2倍扩容如果指定大小，则每次直接按照2倍扩容

LinkedList 底层结构

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

LinkedList底层操作机制

LinkedList底层维护了一个双向链表
LinkedList中维护了两个属性first和last分别指向首节点和尾结点
每个节点（Node）对象，里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表
所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

模拟一个双向链表

java

//定义一个 Node 类，Node 对象 表示双向链表的一个结点
class Node {
	public Object item; //真正存放数据
	public Node next; //指向后一个结点
	public Node pre; //指向前一个结点
	public Node(Object name) {
		this.item = name;
	}
	public String toString() {
		return "Node name=" + item;
	}
}

java

public class LinkedList01 {
    public static void main(String[] args) {
        //模拟一个简单的双向链表

        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node hsp = new Node("老韩");

        //连接三个结点，形成双向链表
        //jack -> tom -> hsp
        jack.next = tom;
        tom.next = hsp;
        //hsp -> tom -> jack
        hsp.pre = tom;
        tom.pre = jack;

        Node first = jack;//让first引用指向jack,就是双向链表的头结点
        Node last = hsp; //让last引用指向hsp,就是双向链表的尾结点


        //演示，从头到尾进行遍历
        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if(first == null) {
                break;
            }
            //输出first 信息
            System.out.println(first);
            first = first.next;
        }

        //演示，从尾到头的遍历
        System.out.println("====从尾到头的遍历====");
        while (true) {
            if(last == null) {
                break;
            }
            //输出last 信息
            System.out.println(last);
            last = last.pre;
        }

        //演示链表的添加对象/数据，是多么的方便
        //要求，是在 tom --------- 老韩直接，插入一个对象 smith

        //1. 先创建一个 Node 结点，name 就是 smith
        Node smith = new Node("smith");
        //下面就把 smith 加入到双向链表了
        smith.next = hsp;
        smith.pre = tom;
        hsp.pre = smith;
        tom.next = smith;

        //让first 再次指向jack
        first = jack;//让first引用指向jack,就是双向链表的头结点

        System.out.println("===从头到尾进行遍历===");
        while (true) {
            if(first == null) {
                break;
            }
            //输出first 信息
            System.out.println(first);
            first = first.next;
        }

        last = hsp; //让last 重新指向最后一个结点
        //演示，从尾到头的遍历
        System.out.println("====从尾到头的遍历====");
        while (true) {
            if(last == null) {
                break;
            }
            //输出last 信息
            System.out.println(last);
            last = last.pre;
        }
    }
}

LinkedList 的增删改查案例

java

public class LinkedListCRUD {
    public static void main(String[] args) {

        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList=" + linkedList);

        //演示一个删除结点的
        linkedList.remove(); // 这里默认删除的是第一个结点
        //linkedList.remove(2);

        System.out.println("linkedList=" + linkedList);

        //修改某个结点对象
        linkedList.set(1, 999);
        System.out.println("linkedList=" + linkedList);

        //得到某个结点对象
        //get(1) 是得到双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);//999

        //因为LinkedList 是 实现了List接口, 遍历方式
        System.out.println("===LinkeList遍历迭代器====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println("next=" + next);

        }

        System.out.println("===LinkeList遍历增强for====");
        for (Object o1 : linkedList) {
            System.out.println("o1=" + o1);
        }
        System.out.println("===LinkeList遍历普通for====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }


        //老韩源码阅读.
        /* 1. LinkedList linkedList = new LinkedList();
              public LinkedList() {}
           2. 这时 linkeList 的属性 first = null  last = null
           3. 执行 添加
               public boolean add(E e) {
                    linkLast(e);
                    return true;
                }
            4.将新的结点，加入到双向链表的最后
             void linkLast(E e) {
                final Node<E> l = last;
                final Node<E> newNode = new Node<>(l, e, null);
                last = newNode;
                if (l == null)
                    first = newNode;
                else
                    l.next = newNode;
                size++;
                modCount++;
            }

         */

        /*
          老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
          1. 执行 removeFirst
            public E remove() {
                return removeFirst();
            }
         2. 执行
            public E removeFirst() {
                final Node<E> f = first;
                if (f == null)
                    throw new NoSuchElementException();
                return unlinkFirst(f);
            }
          3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
            private E unlinkFirst(Node<E> f) {
                // assert f == first && f != null;
                final E element = f.item;
                final Node<E> next = f.next;
                f.item = null;
                f.next = null; // help GC
                first = next;
                if (next == null)
                    last = null;
                else
                    next.prev = null;
                size--;
                modCount++;
                return element;
            }
         */
    }
}

ArryaList 和 LinkedList 比较

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

Set接口和常用方法

Set接口基本介绍

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

Set接口的常用方法

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

Set接口的遍历方式

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

迭代器

增强for

不能使用索引的方式来获取

java

public class SetMethod {
    public static void main(String[] args) {
        //1. 以Set 接口的实现类 HashSet 来讲解Set 接口的方法
        //2. set 接口的实现类的对象(Set接口对象), 不能存放重复的元素, 可以添加一个null
        //3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
        //4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是他的固定.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }

        //遍历
        //方式1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj=" + obj);

        }

        set.remove(null);

        //方式2: 增强for
        System.out.println("=====增强for====");

        for (Object o : set) {
            System.out.println("o=" + o);
        }

        //set 接口对象，不能通过索引来获取


    }
}

hashSet

HashSet实现了Set接口

HashSet实际上是HashMap

java

// 源码
public HashSet(){
  map = new HashMap<>();
}

可以存放null ，但是只能有一个null
HashSet不保证元素是有序的，得到hash后，再确定索引的结果（即:不保证存放元素的顺序和取出顺序一致）
不能有重复元素/对象

java

public class HashSet01 {
    public static void main(String[] args) {
        HashSet set = new HashSet();

        //说明
        //1. 在执行add方法后，会返回一个boolean值
        //2. 如果添加成功，返回 true, 否则返回false
        //3. 可以通过 remove 指定删除哪个对象
        System.out.println(set.add("john"));//T
        System.out.println(set.add("lucy"));//T
        System.out.println(set.add("john"));//F
        System.out.println(set.add("jack"));//T
        System.out.println(set.add("Rose"));//T


        set.remove("john");
        System.out.println("set=" + set);//3个

        //
        set  = new HashSet();
        System.out.println("set=" + set);//0
        //4 Hashset 不能添加相同的元素/数据?
        set.add("lucy");//添加成功
        set.add("lucy");//加入不了
        set.add(new Dog("tom"));//OK
        set.add(new Dog("tom"));//Ok
        System.out.println("set=" + set);

        //在加深一下. 非常经典的面试题.
        //看源码，做分析， 先给小伙伴留一个坑，以后讲完源码，你就了然
        //去看他的源码，即 add 到底发生了什么?=> 底层机制.
        set.add(new String("hsp"));//ok
        set.add(new String("hsp"));//加入不了.
        System.out.println("set=" + set);


    }
}
class Dog { //定义了Dog类
    private String name;

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

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

HashSet底层机制

HashSet 底层是 HashMap
添加一个元素是，先得到hash值（hashCode方法），然后转成索引值
找到存储数据表table,看这个索引位置是否已经存放有元素
如果没有，直接加入
如果有，调用equals比较，如果相同，就放弃添加，如果不相同，则添加在最后
在java8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默认是64)就会进行树化（红黑树）

java

public class HashSetSource {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet();
        hashSet.add("java");//到此位置，第1次add分析完毕.
        hashSet.add("php");//到此位置，第2次add分析完毕
        hashSet.add("java");
        System.out.println("set=" + hashSet);

        /*
        老韩对HashSet 的源码解读
        1. 执行 HashSet()
            public HashSet() {
                map = new HashMap<>();
            }
        2. 执行 add()
           public boolean add(E e) {//e = "java"
                return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
           }
         3.执行 put() , 该方法会执行 hash(key) 得到key对应的hash值 算法h = key.hashCode()) ^ (h >>> 16)
             public V put(K key, V value) {//key = "java" value = PRESENT 共享
                return putVal(hash(key), key, value, false, true);
            }
         4.执行 putVal
         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
                //就是第一次扩容，到16个空间.
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;

                //(1)根据key，得到hash 去计算该key应该存放到table表的哪个索引位置
                //并把这个位置的对象，赋给 p
                //(2)判断p 是否为null
                //(2.1) 如果p 为null, 表示还没有存放元素, 就创建一个Node (key="java",value=PRESENT)
                //(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)

                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
                    Node<K,V> e; K k; //
                    //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                    //并且满足 下面两个条件之一:
                    //(1) 准备加入的key 和 p 指向的Node 结点的 key 是同一个对象
                    //(2)  p 指向的Node 结点的 key 的equals() 和准备加入的key比较后相同
                    //就不能加入
                    if (p.hash == hash &&
                        ((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) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
                          //    注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点
                          //    , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
                          //    注意，在转成红黑树时，要进行判断, 判断条件
                          //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                          //            resize();
                          //    如果上面条件成立，先table扩容.
                          //    只有上面条件不成立时，才进行转成红黑树
                          //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break

                        for (int binCount = 0; ; ++binCount) {
                            if ((e = p.next) == null) {
                                p.next = newNode(hash, key, value, null);
                                if (binCount >= TREEIFY_THRESHOLD(8) - 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)
                    resize();//扩容
                afterNodeInsertion(evict);
                return null;
            }
         */

    }
}

HashSet的扩容和转成红黑树机制

HashSet 底层是 HashMap , 第一次添加时，table数组扩容到16，临界值（threshold）是16*加载因子（loadFactor，0.75）是12
第二次table数组使用到了临界值12，就会扩容到 16*2=32 ，新的临界值就是32*0.75=24，以此类推
在java8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默认是64)就会进行树化（红黑树），否则仍然采用数组扩容机制

java

public class HashSetIncrement {
    public static void main(String[] args) {
        /*
        HashSet底层是HashMap, 第一次添加时，table 数组扩容到 16，
        临界值(threshold)是 16*加载因子(loadFactor)是0.75 = 12
        如果table 数组使用到了临界值 12,就会扩容到 16 * 2 = 32,
        新的临界值就是 32*0.75 = 24, 依次类推

         */
        HashSet hashSet = new HashSet();
//        for(int i = 1; i <= 100; i++) {
//            hashSet.add(i);//1,2,3,4,5...100
//        }
        /*
        在Java8中, 如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是 8 )，
        并且table的大小 >= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),
        否则仍然采用数组扩容机制

         */

//        for(int i = 1; i <= 12; i++) {
//            hashSet.add(new A(i));//
//        }


        /*
            当我们向hashset增加一个元素，-> Node -> 加入table , 就算是增加了一个size++

         */

        for(int i = 1; i <= 7; i++) {//在table的某一条链表上添加了 7个A对象
            hashSet.add(new A(i));//
        }/

        for(int i = 1; i <= 7; i++) {//在table的另外一条链表上添加了 7个B对象
            hashSet.add(new B(i));//
        }



    }
}

class B {
    private int n;

    public B(int n) {
        this.n = n;
    }
    @Override
    public int hashCode() {
        return 200;
    }
}

class A {

LinkedHashSet

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

LinkedHashSet练习

java

public class LinkedHashSetExercise {
    public static void main(String[] args) {

        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add(new Car("奥拓", 1000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//OK
        linkedHashSet.add(new Car("法拉利", 10000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//加入不了
        linkedHashSet.add(new Car("保时捷", 70000000));//OK
        linkedHashSet.add(new Car("奥迪", 300000));//加入不了

        System.out.println("linkedHashSet=" + linkedHashSet);

    }
}

/**
 * Car 类(属性:name,price)，  如果 name 和 price 一样，
 * 则认为是相同元素，就不能添加。 5min
 */

class Car {
    private String name;
    private double price;

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

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

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

    //重写equals 方法 和 hashCode
    //当 name 和 price 相同时， 就返回相同的 hashCode 值, equals返回t

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 &&
                Objects.equals(name, car.name);
    }

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

LinkedHashSet底层机制

LinkedHashSet 加入顺序和取出元素/数据的顺序一致
LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
LinkedHashSet 底层结构 (数组table+双向链表)
添加第一次时，直接将数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry
数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry类型

java

public class LinkedHashSetSource {
    public static void main(String[] args) {
        //分析一下LinkedHashSet的底层机制
        Set set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer("刘", 1001));
        set.add(123);
        set.add("HSP");

        System.out.println("set=" + set);
        //老韩解读
        //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致
        //2. LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
        //3. LinkedHashSet 底层结构 (数组table+双向链表)
        //4. 添加第一次时，直接将 数组table 扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry
        //5. 数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry类型
        /*
                //继承关系是在内部类完成.
                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);
                    }
                }

         */

    }
}
class Customer {
    private String name;
    private int no;

    public Customer(String name, int no) {
        this.name = name;
        this.no = no;
    }
}

Map

Map 和 Collection 是并列存在。用于保存具有映射关系的数据：Key - Value
Map 中的 key 和 value 可以是任何引用类型的数据，会封装到 HashMap$Node 对象中
Map 中的 key 是不允许重复的，原因和 HashSet 一样
Map 中的 value 可以重复
Map 中的 key 可以为 null, value 也可以为 null，注意 key 为 null 只能有一个，value 为 null 可以有多个
常用 String 类作为 Map 的 Key
Key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value

Map常用方法

java

// put 添加数据
map.put(key,value); 

//remove:根据键删除映射关系
map.remove(null);
System.out.println("map=" + map);

//get：根据键获取值
Object val = map.get("鹿晗");
System.out.println("val=" + val);

//size:获取元素个数
System.out.println("k-v=" + map.size());

//isEmpty:判断个数是否为 0
System.out.println(map.isEmpty());//F

//clear:清除 k-v
//map.clear();
System.out.println("map=" + map);

// containsKey:查找键是否存在
System.out.println("结果=" + map.containsKey("hsp"));

Map遍历方式

containsKey：查找键是否存在
keySet:获取所有的键
entrySet:获取所有的关系k-v
values:获取所有的值

方式一：先取出所有的Key，通过Key取出对应的Value

java

Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿晗", "关晓彤");


Set keyset = map.keySet();


//(1) 增强 for
System.out.println("-----第一种方式-------");
for (Object key : keyset) {
	System.out.println(key + "-" + map.get(key));
}

//(2) 迭代器
System.out.println("----第二种方式--------");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
	Object key = iterator.next();
	System.out.println(key + "-" + map.get(key));
}

方式二：把所有的value取出

java

Collection values = map.values();
//这里可以使用所有的 Collections 使用的遍历方法
//(1) 增强 for
System.out.println("---取出所有的 value 增强 for----");
for (Object value : values) {
	System.out.println(value);
}

//(2) 迭代器
System.out.println("---取出所有的 value 迭代器----");
Iterator iterator2 = values.iterator();
while (iterator2.hasNext()) {
	Object value = iterator2.next();
  System.out.println(value);
}

方式三：通过 EntrySet 来获取 k-v

java

Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
//(1) 增强 for
System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----");
for (Object entry : entrySet) {
	//将 entry 转成 Map.Entry
	Map.Entry m = (Map.Entry) entry;
	System.out.println(m.getKey() + "-" + m.getValue());
}

//(2) 迭代器
System.out.println("----使用 EntrySet 的 迭代器(第 4 种)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
	Object entry = iterator3.next();
	//System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
	//向下转型 Map.Entry
	Map.Entry m = (Map.Entry) entry;
	System.out.println(m.getKey() + "-" + m.getValue());
}

HashMap

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

HashMap底层机制

HashMap底层维护了Node类型的数组table，默认为null
当创建对象实，将加载因子（loadfactor）初始化为 0.75
当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引出是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key和准备加入的key是否相同，如果相同，则直接替换val;如果不相同则需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容
第一次添加，则需要扩容table容量为16，临界值（threshold）为12 （16*0.75）
以后再扩容，则需要扩容table容量为原来的2倍（32），临界值为原来的2倍，即24，以次类推
在java8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是8)，并且table的大小 >= MIN_TREEIFY_CAPACITY(默认是64)就会进行树化（红黑树），否则仍然采用数组扩容机制

java

HashMap map = new HashMap();
        map.put("java", 10);//ok
        map.put("php", 10);//ok
        map.put("java", 20);//替换value

        System.out.println("map=" + map);//

        /*老韩解读HashMap的源码+图解
        1. 执行构造器 new HashMap()
           初始化加载因子 loadfactor = 0.75
           HashMap$Node[] table = null
        2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
            public V put(K key, V value) {//K = "java" value = 10
                return putVal(hash(key), key, value, false, true);
            }
         3. 执行 putVal
         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 数组为null, 或者 length =0 , 就扩容到16
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;
                //取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v
                //, 创建成一个 Node ,加入该位置即可
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    Node<K,V> e; K k;//辅助变量
                // 如果table的索引位置的key的hash相同和新的key的hash值相同，
                 // 并 满足(table现有的结点的key和准备添加的key是同一个对象  || equals返回真)
                 // 就认为不能加入新的k-v
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {
                        //如果找到的结点，后面是链表，就循环比较
                        for (int binCount = 0; ; ++binCount) {//死循环
                            if ((e = p.next) == null) {//如果整个链表，没有和他相同,就加到该链表的最后
                                p.next = newNode(hash, key, value, null);
                                //加入后，判断当前链表的个数，是否已经到8个，到8个，后
                                //就调用 treeifyBin 方法进行红黑树的转换
                                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
                                ((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; //替换，key对应value
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;//每增加一个Node ,就size++
                if (++size > threshold[12-24-48])//如size > 临界值，就扩容
                    resize();
                afterNodeInsertion(evict);
                return null;
            }

              5. 关于树化(转成红黑树)
              //如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
              //否则才会真正的树化 -> 剪枝
              final void treeifyBin(Node<K,V>[] tab, int hash) {
                int n, index; Node<K,V> e;
                if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                    resize();

            }
         */

Hashtable

存放的元素是键值对：k-v
HashTable的键和值都不能为null,否则会抛出NullPointerException
HashTable使用方法基本上和HashMap一样
HashTable是线程安全的（synchronized），HashMap是线程不安全的

HashTable 和 HashMap 对比

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

Properties

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

Properties基本使用

java

//老韩解读
//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据，当然 key 和 value 不能为 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的 key ， value 被替换
System.out.println("properties=" + properties);

//通过 k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
System.out.println("properties=" + properties);
//修改
properties.put("john", "约翰");
System.out.println("properties=" + properties);

TreeSet

TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类) 并指定排序规则
当我们使用无参构造器，创建TreeSet时，仍然是无序的

java

//老韩解读
        //1. 当我们使用无参构造器，创建TreeSet时，仍然是无序的
        //2. 老师希望添加的元素，按照字符串大小来排序
        //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
        //   并指定排序规则
        //4. 简单看看源码
        //老韩解读
        /*
        1. 构造器把传入的比较器对象，赋给了 TreeSet的底层的 TreeMap的属性this.comparator

         public TreeMap(Comparator<? super K> comparator) {
                this.comparator = comparator;
            }
         2. 在 调用 treeSet.add("tom"), 在底层会执行到

             if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
                do {
                    parent = t;
                    //动态绑定到我们的匿名内部类(对象)compare
                    cmp = cpr.compare(key, t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else //如果相等，即返回0,这个Key就没有加入
                        return t.setValue(value);
                } while (t != null);
            }
         */

//        TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面 调用String的 compareTo方法进行字符串大小比较
                //如果老韩要求加入的元素，按照长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        //添加数据.
        treeSet.add("jack");
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3


        System.out.println("treeSet=" + treeSet);

TreeMap

与TreeSet一样 TreeMap 提供的一个构造器，可以传入一个比较器(匿名内部类) 并指定排序规则
使用默认的构造器，创建TreeMap, 是无序的(也没有排序)

java

public class TreeMap_ {
    public static void main(String[] args) {

        //使用默认的构造器，创建TreeMap, 是无序的(也没有排序)
        /*
            老韩要求：按照传入的 k(String) 的大小进行排序
         */
//        TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照传入的 k(String) 的大小进行排序
                //按照K(String) 的长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("hsp", "韩顺平");//加入不了

        System.out.println("treemap=" + treeMap);

        /*

            老韩解读源码：
            1. 构造器. 把传入的实现了 Comparator接口的匿名内部类(对象)，传给给TreeMap的comparator
             public TreeMap(Comparator<? super K> comparator) {
                this.comparator = comparator;
            }
            2. 调用put方法
            2.1 第一次添加, 把k-v 封装到 Entry对象，放入root
            Entry<K,V> t = root;
            if (t == null) {
                compare(key, key); // type (and possibly null) check

                root = new Entry<>(key, value, null);
                size = 1;
                modCount++;
                return null;
            }
            2.2 以后添加
            Comparator<? super K> cpr = comparator;
            if (cpr != null) {
                do { //遍历所有的key , 给当前key找到适当位置
                    parent = t;
                    cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else  //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加
                        return t.setValue(value);
                } while (t != null);
            }
         */

    }
}

总结

在开发中，选择什么集合实现类，主要取决于业务操作特点,然后根据集合实现类惊醒选择，分析如下：

先判断存储类型（一组对象【单列】或一组键值对【双列】]）
一组对象【单列】: Collection接口
允许重复：List
增删多：LinkedList（线程不安全，底层维护了一个双向链表）、Vector（线程安全）
改查多：ArrayList（底层维护Object类型的可变数据）
不允许重复：Set
无序：HashSet（底层是HashMap，维护一个哈希表，即数组+链表+红黑树）
排序：TreeSet
插入和取出顺序一致：LinkedHashSet（数组+双向链表）
一组键值对：Map
键无序：HashMap (底层是哈希表，jdk7：数组+链表，jdk8：数组+链表+红黑树)
键排序：TreeMap
键插入和取出顺序一致：LinkedHashMap
读取文件：Properties

Collections工具类

Collections是一个操作Set，List，Map等集合的工具类
Collectoins中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
Collections提供的方法均为static方法

java

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");
        list.add("tom");


//        reverse(List)：反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println("list=" + list);
//        shuffle(List)：对 List 集合元素进行随机排序
//        for (int i = 0; i < 5; i++) {
//            Collections.shuffle(list);
//            System.out.println("list=" + list);
//        }

//        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println("自然排序后");
        System.out.println("list=" + list);
//        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);
//        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

        //比如
        Collections.swap(list, 0, 1);
        System.out.println("交换后的情况");
        System.out.println("list=" + list);

        //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        System.out.println("自然顺序最大元素=" + Collections.max(list));
        //Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        //比如，我们要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("长度最大的元素=" + maxObject);


        //Object min(Collection)
        //Object min(Collection，Comparator)
        //上面的两个方法，参考max即可

        //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));

        //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);

        //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
        //如果list中，有tom 就替换成 汤姆
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list替换后=" + list);

        
    }
}

集合和Map ​

集合和Map继承图 ​

Collection 接口和常用方法 ​

Collection 接口实现类的特点 ​

Collection 接口遍历元素方式 ​

使用 Iterator(迭代器) ​

迭代器基本介绍 ​

Iterator接口的方法 ​

增强for循环遍历 ​

List接口和常用方法 ​

List 接口基本介绍 ​

常用方法 ​

List 的三种遍历方式 ​

ArrayList 底层结构和源码分析 ​

ArrayList注意事项 ​

ArrayList的底层操作机制 ​

Vecotr底层机制和源码剖析 ​

源码剖析 ​

Vector 和 ArrayList的比较 ​

LinkedList 底层结构 ​

LinkedList底层操作机制 ​

模拟一个双向链表 ​

LinkedList 的增删改查案例 ​

ArryaList 和 LinkedList 比较 ​

Set接口和常用方法 ​

Set接口基本介绍 ​

Set接口的常用方法 ​

Set接口的遍历方式 ​

hashSet ​

HashSet底层机制 ​

HashSet的扩容和转成红黑树机制 ​

LinkedHashSet ​

LinkedHashSet练习 ​

LinkedHashSet底层机制 ​

Map ​

Map常用方法 ​

Map遍历方式 ​

方式一：先取出所有的Key，通过Key取出对应的Value ​

方式二：把所有的value取出 ​

方式三：通过 EntrySet 来获取 k-v ​

HashMap ​

HashMap底层机制 ​

Hashtable ​

HashTable 和 HashMap 对比 ​

Properties ​

Properties基本使用 ​

TreeSet ​

TreeMap ​

总结 ​

Collections工具类 ​

集合和Map

集合和Map继承图

Collection 接口和常用方法

Collection 接口实现类的特点

Collection 接口遍历元素方式

使用 Iterator(迭代器)

迭代器基本介绍

Iterator接口的方法

增强for循环遍历

List接口和常用方法

List 接口基本介绍

常用方法

List 的三种遍历方式

ArrayList 底层结构和源码分析

ArrayList注意事项

ArrayList的底层操作机制

Vecotr底层机制和源码剖析

源码剖析

Vector 和 ArrayList的比较

LinkedList 底层结构

LinkedList底层操作机制

模拟一个双向链表

LinkedList 的增删改查案例

ArryaList 和 LinkedList 比较

Set接口和常用方法

Set接口基本介绍

Set接口的常用方法

Set接口的遍历方式

hashSet

HashSet底层机制

HashSet的扩容和转成红黑树机制

LinkedHashSet

LinkedHashSet练习

LinkedHashSet底层机制

Map

Map常用方法

Map遍历方式

方式一：先取出所有的Key，通过Key取出对应的Value

方式二：把所有的value取出

方式三：通过 EntrySet 来获取 k-v

HashMap

HashMap底层机制

Hashtable

HashTable 和 HashMap 对比

Properties

Properties基本使用

TreeSet

TreeMap

总结

Collections工具类