目录

集合框架库

0要点

0.1重点

0.2接口简要介绍

1Collection接口

1.1List接口

1.2Set接口

1.3Queue接口

2Map接口

2.0哈希表

2.1HashMap

2.2LinkedHashMap

2.3TreeMap

2.4WeakHashMap

2.4.1强引用：

---

集合框架库

0要点

0.1重点

①顶层接口的学习：Collection接口（子接口：List接口，Set接口，Queue接口），map接口

②接口实现类介绍：结合源代码学会使用对象的方法、特点、底层数据结构，可以自定义实现集合。

③迭代器的学习。

④理清集合框架图，如图所示。

（虚线框表示接口，实线框表示实现类）

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

0.2接口简要介绍

顶层接口：

Collection：存储相同类型的数据，都是存储单个元素

Map：key-value键值对形式存储

Collection子接口：(数据是否可以重复性、有序性(插入顺序)、是否存储null值)

List：数据可重复、保证有序性、可以存储null ->ArrayList（底层是数组、线程不安全的集合）、Vector（底层是数组、线程安全的集合）、LinkedList（底层是链表）

Set：数据不重复、无法保证有序性、不可以存储null ->HashSet(底层是哈希表结构、去重)、LinkedHashSet(底层是哈希表结构、去重、插入有序)、TreeSet(底层是红黑树结构、去重、有序(基于数据特征))

Queue：数据可以重复，保证有序(基于数据特征)、不可以存储null ->PriortyQueue(优先级队列) 堆

Map接口下的实现类：

HashMap:key底层是哈希表、不能重复，key和value可以为null，线程不安全的

HashTable:底层是哈希表、key不能重复，key可以为null，线程安全的

LinkedHashMap：底层是哈希表、继承自HashMap，保证数据的有序性（插入有序）

TreeMap：保证数据的有序性（默认按从小到大排序）

weakHashMap：

---

1Collection接口

Collection接口通常不能直接使用，该接口提供了添加、删除、管理元素的方法。因为List和Set接口都继承Collection接口，所以对List和Set集合都实用。

共性方法：

add()//添加元素

clear()//清空所有元素

remove()//删除元素，成功删除返回true，失败返回false

contains()//查看集合中是否包含该元素

isEmpty()//集合是否为空

size()//集合的大小

toArray()//吧集合中的元素存储到数组中

利用实现类ArrayList来研究接口方法：

public static void main(String[] args) {//创建ArrayList实例研究Collection接口的方法ArrayList<Integer> arrayList = new ArrayList<>();ArrayList<Integer> arrayList1 = new ArrayList<>();arrayList1.add(9);arrayList1.add(8);
​//添加元素 1  boolean add(E e)arrayList.add(1);arrayList.add(9);
​//添加arrayList1集合  boolean addAll(Collection<? extends E> c)arrayList.addAll(arrayList1);
​//获取集合中元素的个数  int size()System.out.println("arrayList元素个数："+arrayList.size());
​//获取元素 通过指定下标获取元素    E get(int index)System.out.println("通过下标获取0号元素:"+arrayList.get(0));
​//for循环遍历集合System.out.print("arrayList集合中的元素：");for(int i = 0;i<arrayList.size();i++){System.out.print(arrayList.get(i)+"\t");}System.out.println();
​//删除集合中所有元素 void clear()arrayList1.clear();System.out.println("arrayList1中的元素个数："+arrayList1.size());
​//查询是否包含指定元素 1 boolean contains(Object o)boolean contains = arrayList.contains(1);System.out.println("arrayList中是否包含指定元素 1:"+contains);
​//查询是否包含子集合  boolean containsAll(Collection<?> c)boolean b = arrayList.containsAll(arrayList1);System.out.println("arrayList中是否包含子集合:"+b);
​// 判断集合是否为空  boolean isEmpty()boolean empty = arrayList1.isEmpty();System.out.println("arrayList1是否为空："+empty);
​//删除指定元素 注意：只找到第一个相同的元素进行删除arrayList.remove(Integer.valueOf(9));
​//迭代器Iterator<Integer> iterator = arrayList.iterator();System.out.println("去除元素9之后：arrayList集合中的元素：");while (iterator.hasNext()){System.out.print(iterator.next()+"\t");}System.out.println();
​
​
​//保留集合中的指定元素(留下的是list的元素)      retainall(list);arrayList.retainAll(arrayList1);//迭代器Iterator<Integer> iterator1 = arrayList.iterator();System.out.println("去除元素后：arrayList集合中的元素：");//集合为空while (iterator1.hasNext()){System.out.print(iterator1.next()+"\t");}System.out.println();
}

迭代器：Collection集合元素的通用获取方式。在取出元素先判断集合中有没有元素，有就取出，然后继续判断有没有，有就继续取出，直到所有元素全部被取出。

功能：

1.能够遍历一个集合/容器

2.我们不需要了解容器内部结构

Iterator()接口常用方法：

next():返回下一元素。

hasNext()：判断下一元素是否存在。有则返回true。

remove():移除下一个元素

使用步骤： 

1.1List接口

继承Collection接口

1、有序的集合

2、有索引

3、允许存储重复的元素

4、允许存储一个或者多个null值

提供的特有方法(和索引有关)：

add(int index，E element)//添加元素到指定索引位置

get(int index)//通过索引获取对应位置的值

set(int index，E element)//将索引位置的值替换成新值，并将旧值返回出来

remove(int index)//删除索引位置的值，返回删除的元素

public static void main(String[] args) {//创建ArrayList实例研究List接口的方法ArrayList<Integer> arrayList = new ArrayList<>();ArrayList<Integer> arrayList1 = new ArrayList<>();arrayList.add(0);arrayList.add(1);arrayList1.add(9);
​
​//迭代器Iterator<Integer> iterator = arrayList.iterator();System.out.println("arrayList集合中的元素：");while (iterator.hasNext()) {System.out.print(iterator.next() + "\t");}System.out.println();//添加元素（尾部）     add(E e);arrayList.add(3);
​//迭代器Iterator<Integer> iterator1 = arrayList.iterator();System.out.println("添加元素后：arrayList集合中的元素：");while (iterator1.hasNext()) {System.out.print(iterator1.next() + "\t");}System.out.println();
​
//在指定位置index插入元素element   add(int index,E element);arrayList.add(2, 2);
​//迭代器Iterator<Integer> iterator2 = arrayList.iterator();System.out.println("插入元素后：arrayList集合中的元素：");while (iterator2.hasNext()) {System.out.print(iterator2.next() + "\t");}System.out.println();
​
//将已有的Collection的集合的对象的数据插入当前集合  addAll(list1);arrayList.addAll(arrayList1);
​//迭代器Iterator<Integer> iterator3 = arrayList.iterator();System.out.println("添加集合后：arrayList集合中的元素：");while (iterator3.hasNext()) {System.out.print(iterator3.next() + "\t");}System.out.println();
​
//在指定位置插入集合对象  addAll(int index,Collection<? extends E> c);arrayList.addAll(2, arrayList1);
​//迭代器Iterator<Integer> iterator4 = arrayList.iterator();System.out.println("插入集合后：arrayList集合中的元素：");while (iterator4.hasNext()) {System.out.print(iterator4.next() + "\t");}System.out.println();
​
//删除指定对象元素   remove(Integer.valueOf(7));arrayList.remove(Integer.valueOf(2));
​//迭代器Iterator<Integer> iterator5 = arrayList.iterator();System.out.println("去除元素后：arrayList集合中的元素：");while (iterator5.hasNext()) {System.out.print(iterator5.next() + "\t");}System.out.println();
​
//删除指定位置的元素 remove(int index);arrayList.remove(0);
​//迭代器Iterator<Integer> iterator6 = arrayList.iterator();System.out.println("去除元素后：arrayList集合中的元素：");while (iterator6.hasNext()) {System.out.print(iterator6.next() + "\t");}System.out.println();
//删除指定集合里的数据(删除有list中的元素)  removeAll(list);arrayList.removeAll(arrayList1);
​//迭代器Iterator<Integer> iterator7 = arrayList.iterator();System.out.println("去除集合后：arrayList集合中的元素：");while (iterator7.hasNext()) {System.out.print(iterator7.next() + "\t");}System.out.println();
​
//修改操作,指定位置index修改成某值element   set(int index,E element);arrayList.set(0, 8);
​//迭代器Iterator<Integer> iterator8 = arrayList.iterator();System.out.println("修改元素后：arrayList集合中的元素：");while (iterator8.hasNext()) {System.out.print(iterator8.next() + "\t");}System.out.println();
​
//查询操作,查询指定位置index的元素  get(int index);System.out.println("0号位置的元素：" + arrayList.get(0));
//部分数据  从起始位置fromIndex到toIndex的数据获取   subList(int fromIndex,int toIndex);System.out.println("0-2号位置的元素：" + arrayList.subList(0, 2));
​}

数据可以重复，可以存储null值，安全性

基本数据结构：数组，链表，队列，栈，堆……主要在存储数据时组织数据存储的方式不同

集合底层也是依赖基础的数据结构来存储

1、集合可以动态扩容：数组则是开辟一段连续的内存空间

2、集合提供丰富API接口，方便使用：数组移动（删除，添加）需要自行考虑，集合可以自动移动，提供专有的API接口，不需要关注底层实现

1.1.1ArrayList集合

ArrayList是List接口的一个实现类

特点

1、数据有序

2、底层基于数组实现，

3、可以存储null

4、不支持多线程

例：求两个集合的交并补集

  public static void main(String[] args) {ArrayList<Integer> a = new ArrayList<Integer>();//集合aArrayList<Integer> b = new ArrayList<Integer>();//集合ba.add(1);a.add(2);a.add(3);b.add(3);b.add(4);b.add(5);//a:1 2 3    b: 3 4 5//并集  1 2 3 4 5a.addAll(b);//交集  3
//        a.retainAll(b);//差集  1 2
//        b.retainAll(a);   //将b集合变成和a集合的交集
//        a.removeAll(b);   //在将a集合中属于a,b交集的部分去除掉//迭代器Iterator<Integer> it = a.iterator();while (it.hasNext()){System.out.print(it.next()+"  ");}}

并集结果：

交集结果：

差集结果：

源码分析

底层采用的数据结构是数组，由于数组查询快，增删慢，所以ArrayList集合适合用于多查询少增删的场景

这是add()添加方法底层实现的逻辑：添加元素时数组扩容重新申请一个size+1的数组，将原数组复制去新的数组,将新元素添加到新数组的最后。

继承关系

 ArrayList<E> extends AbstractList<E>,

implements List<E>, RandomAccess, Cloneable, java.io.Serializable

而AbstractList<E>继承自List接口，对接口中的方法进行了实现，

---

1.1.2LinkedList集合

特点：

有序

底层是链表（查询慢，增删快）

不支持多线程

特有方法：

import java.util.LinkedList;public class LinkedListTest {/*public void addFirst(E e) :将指定元素插入列表开头public void addLast(E e)：将指定元素添加到列表结尾public void push(E e):将元素推入此列表所表示的堆栈 和addFirst()效果相等public E getFirst()：返回列表的第一个元素public E getLast()：返回列表的最后一个元素public E removeFirst()：移除并返回列表的第一个元素public E removeLast()：移除并返回列表的最后一个元素public E pop()：从列表所表示的堆栈中弹出一个元素 和removeFirst()效果相等public boolean isEmpty() ：如果队列不包含元素，返回true*/public static void main(String[] args) {LinkedList<Integer> linkedList = new LinkedList<>();linkedList.addFirst(1);linkedList.addLast(2);linkedList.push(3);System.out.println(linkedList);Integer first = linkedList.getFirst();System.out.println("first:" + first);Integer last = linkedList.getLast();System.out.println("last:" + last);Integer removeFirst = linkedList.removeFirst();System.out.println("removeFirst:" + removeFirst);Integer removeLast = linkedList.removeLast();System.out.println("removeLast:" + removeLast);Integer pop = linkedList.pop();System.out.println("pop:" + pop);boolean empty = linkedList.isEmpty();System.out.println("empty:" + empty);}
}

1.1.3ArrayList和LinkedList的比较

区别：

①底层数据结构不同：ArrayList是基于动态数组的数据结构，LinkedList基于双向链表的数据结构

②访问效率：对于get和set方法，ArrayList优于LinkedList

③修改效率：add和remove方法，LinkedList优于ArrayList

缺点：

ArrayList会存在一定的空间浪费，在创建时会预留一部分的容量空间

ArrayList删除等操作会涉及当前元素后续元素的移动，插入和删除某一固定位置的对象时速度比较慢。

应用场景

ArrayList运用在查询比较多，修改比较少的场景

LinkedList运用在修改比价多，查询比较少的场景

---

1.1.4Vactor集合

和ArrayList集合类似，底层是数组。但是Vactor是单线程的，线程安全，速度慢

1.1.5Stack

---

1.2Set接口

继承Collection接口

set接口的实现类：HashSet、LinkedHashSet和TreeSet

Set接口特点：数据是不能重复的、最多可以存储一个null值，无索引

Set接口提供的方法API：

底层数组是哈希表：

先来了解一下哈希值。

哈希值：十进制整数，由系统随机给出，逻辑地址，模拟出来得到的地址，不是物理地址。

在Object类中有一个方法，可以获取对象的哈希值

int hashCode() 返回该对象的哈希码值

jdk1.8之前：哈希表 = 数组 + 链表

jdk1.8之后：哈希表 = 数组 + 红黑树

数组结构把元素进行了分组（相同哈希值的分为1组），链表/红黑树把相同的哈希值的元素连接到一起。

哈希表特点:查询速度快

哈希冲突：元素内容不同但哈希值相同。

不允许重复元素的原理：

使用set集合保证数据唯一的前提是需要 equals方法和hashCode方法

基本数据类型都重写了equals方法和hashCode方法，可以直接使用，如果是自定义的数据类型，需要自己重写后才能正常使用

1.2.1HashSet集合

特点：

1、HashSet不能保证数据有序（无序）

2、HashSet数据是不能重复的

3、HashSet是可以存储null值

4、底层是哈希表结构（查询速度快）

hashSet属性：

//map属性是存储数据的，是HashMap类型的数据
private transient HashMap<E,Object> map;
//PRESENT属性，
private static final Object PRESENT = new Object();

HashSet底层实现是基于HashMap来实现的，将set中存储的值作为HashMap的key来处理，PRESENT是一个填充的value值

HashMap的构造函数：

public HashSet() {map = new HashMap<>();}
​public HashSet(Collection<? extends E> c) {map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));addAll(c);}
​public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<>(initialCapacity, loadFactor);}
​
​public HashSet(int initialCapacity) {map = new HashMap<>(initialCapacity);}

HashSet方法:

 public boolean add(E e) {return map.put(e, PRESENT)==null;}

HashSet应用场景：

在做数据去重的场景下使用

1.2.2LinkedHashSet集合

LinkedHashSet特点：

1、数据有序

2、数据不能重复

3、数据是可以存储null的

4、底层是一个哈希表：数组+链表/红黑树+链表：多了一条链表来记录元素的存储顺序，保证了元素有序

LinkedHashSet的源码实现：

public class LinkedHashSet<E> extends HashSet<E>implements Set<E>, Cloneable, java.io.Serializable {
​public LinkedHashSet(int initialCapacity, float loadFactor) {super(initialCapacity, loadFactor, true);}
​
​public LinkedHashSet(int initialCapacity) {super(initialCapacity, .75f, true);}
​
​public LinkedHashSet() {super(16, .75f, true);}
​
​public LinkedHashSet(Collection<? extends E> c) {super(Math.max(2*c.size(), 11), .75f, true);addAll(c);}
}

通过声明形式可知：其继承自HashSet，其继承了HashSet中所有的属性和方法

构造函数调用父类HashSet中方法如下：

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new <>(initialCapacity, loadFactor);}

LinkedHashSet的实现是基于LinkedHashMap来实现的

LinkedHashSet数据有序的特征是基于LinkedHashMap来保证的，其底层利用双向链表来实现的数据有序

LinkedHastSet的应用场景：

在去重的基础上数据有序

1.2.3TreeSet集合

 TreeSet <Integer> treeSet = new TreeSet <Integer>();treeSet.add(3);treeSet.add(1);treeSet.add(6);treeSet.add(1);

treesSet特点：

1、数据自然有序(自定义排序，实现Comparator接口)

2、数据不能重复

3、数据不能为null

通过源码可知：TreeSet底层是基于treeMap来实现的

TreeSet引用场景

数据需要去重，且数据按照特定大小进行排序

---

1.3Queue接口

队列：

先进先出

queue接口除了实现collection接口下的基本方法，还提供了特殊方法，和collection接口不同的是：

常用API：

优先级队列

PriorityQueue特点：

1、数据是按照一定的优先级进行排序，默认是从小到大排序（集合内部不是有序的，只能保证队头第一个元素是最小/最大值）

2、不能存储null值

3、存储元素可以重复

优先级队列底层实现的数据结构是：堆

小根堆的实现

添加元素

添加在堆尾，判断该节点和父节点的大小关系，若小于父节点，则交换位置，接着和当前的父节点继续比较，直到不在交换为止（当前节点大于父节点）。

删除元素

删除堆头的元素，把最后一个元素放在堆头位置，向下调整，找左右孩子中最小的和当前节点调整，接着判断该节点与当前的左右孩子中的最小的比较，直到碰到叶子节点或者当前节点小于左右孩子时停止。

自定义实现优先级队列

public class DIYPriorityQueue212 {    //数据的存储private Integer data[];     //存储数据个数    private int size;  private Integer capcity;public DIYPriorityQueue212(Integer initcapcity) {data = new Integer[initcapcity];size = 0;capcity = initcapcity;}public DIYPriorityQueue212() {this(16);}//插入数据   public void add(Integer v) {//判断容量是否满足       if (size >= capcity) {//扩容处理        }       if (size == 0) {data[0] = v;} else {data[size] = v;//进行调整          siftUp(size);}size++;}//向上调整 private void siftUp ( int k){while (k > 0) {int parentIndex = (k - 1) / 2;if (data[parentIndex] > data[k]) {                //父节点大于当前节点                               int tmp = data[k];                               data[k] = data[parentIndex];                     data[parentIndex] = tmp;                          k = parentIndex; } else {break;}}}//向下调整private void siftDown ( int k){int half = size / 2; //找到所有的非叶子节点       while (k < half) {int child = k * 2 + 1;int rchild = k * 2 + 2;//找到最小孩子的索引位置并赋给child                 if (rchild < size && (data[child] >             data[rchild])){    child = rchild;}if (data[k] > data[child]) {int tmp = data[k];data[k] = data[child];data[child] = tmp;k = child;} else {break;}}}//删除数据    public Integer remove() {if (size == 0) {return null;}int oldValue = data[0];data[0] = data[size - 1];///向下调整        siftDown(0);data[size - 1] = null;size--;return oldValue;}//获取堆顶元素   public Integer peek() {return data[0];} 

//作业;

自定义实现一个大根堆的优先级队列（要支持泛型）

comparable和的 比较

源码实现

1、类的继承形式

继承extends AbstractQueue

2、属性

3、构造函数

4、默认值、默认属性

5、扩容机制

6、常用的方法

---

2Map接口

存储形式：键值对K-V

Map接口：
存储的是键值对形式,key-value键值对存在，key值是不能重复的，value是可以重复的

Map接口下方法：

集合中常用方法解释：

        // V put(K key, V value) 向集合中添加键值对hashMap.put("张杰","谢娜");
//        hashMap.put("张杰","谢娜2");System.out.println(hashMap.size());//void clear()  将集合元素清空处理
//        hashMap.clear();//boolean containsKey(Object key)  判断集合中是否存在指定的键 key  存在返回true  不存在返回falseboolean key = hashMap.containsKey("战三");
//        System.out.println(key);//boolean containsValue(Object value) 判断集合中是否存在指定的值value  存在返回true  不存在返回falsehashMap.containsValue("zhangsna");
//        System.out.println(hashMap.size());//V get(Object key) 通过键key获取valueString s = hashMap.get("张杰");

Map接口下集合的遍历形式：

/通过entrySet遍历键值对Iterator <Map.Entry <String, String>> iterator = hashMap.entrySet().iterator();while (iterator.hasNext()) {Map.Entry <String, String> entry = iterator.next();System.out.println("key:"+entry.getKey()+",value:"+entry.getValue()+ " ");}//通过keySet遍历键Iterator <String> iterator1 = hashMap.keySet().iterator();while (iterator1.hasNext()) {String key1 = iterator1.next();System.out.print(key1+" ");}//通过values()遍历值Iterator <String> iterator2 = hashMap.values().iterator();while (iterator2.hasNext()) {String value = iterator2.next();System.out.print(value+" ");}

2.0哈希表的介绍

HashMap哈希表（也叫关联数组）一种通用的数据结构，哈希表是一种通过关键码去寻找值得数据映射结构

几个专业的词汇

键(key)：又称为关键字。唯一的标示要存储的数据，可以是数据本身或者数据的一部分。

槽(slot/bucket)：哈希表中用于保存数据的一个单元，也就是数据真正存放的容器。

哈希函数(hash function)：将键(key)映射(map)到数据应该存放的槽(slot)所在位置的函数。

哈希冲突(hash collision)：哈希函数将两个不同的键映射到同一个索引的情况。

构造哈希函数的方法：

1、直接寻址法：

2、除留余数法：

哈希冲突的解决

1、链地址法：

当出现哈希冲突时，在冲突的地方通过链表来解决

这个图中h(x) = x mod 10 ;是一个哈希函数，可见代入x=91和x=1的时候都会到映射到键值为1的slot，那么这样就会引发冲突，在链地址法中，用链表延展去存储同键值的数据。

优点：

1、处理冲突简单，无堆积现象，非同义词不会产生冲突，平均查找时间短

2、在用链地址构造的散列表中，删除结点的操作易于实现

2、线性探测法

通过散列函数hash(key)，找到关键字key在线性序列中的位置，如果当前位置已经有了一个关键字，就长生了哈希冲突，就往后探测i个位置（i小于线性序列的大小），直到当前位置没有关键字存在。

2.1HashMap

特点

1.数据没有顺序

2.key 值不能重复,value值可以重复

3.可以存储null值

遍历形式

1、以键值对的形式遍历，通过entrySet(),得到Set集合 迭代器数据类型：Map.Entry<String,String>

2、以键的形式遍历，通过keySet()提供的方法

3、以value形式进行遍历，通过values()

分析HashMap源码

继承结构

构造函数

属性

扩容机制

二倍扩容

常见方法

put方法

remove方法

应用场景

数据统计

***底层实现方式

HashTable:和HashMap类似，但它是单线程，线程安全的，速度慢。并且不能存储null值null键。

2.2LinkedHashMap

2.2.1LinkedHashMap的定义：

public class LinkedHashMap<K,V>extends HashMap<K,V>implements Map<K,V>

HashMap,HashTable,LinkedHashMap底层数组初始容量为16

LinkedHashMap继承自HashMap，默认值，扩容，加载因子(0.75)等都相同

但唯一不同的就是:插入有序

2.2.2特有属性

transient LinkedHashMap.Entry<K,V> head;
//默认(flase)插入有序   true是访问有序final boolean accessOrder;

2.2.3put操作

2.3TreeMap

2.3.1特点：

有序,能够按照key大小排序

key不可以存null值，key不能重复

2.3.2红黑树：

如何做到数据有序？ 红黑树

~红黑树：是一颗二叉树

{二叉树特征：树中的任何一个节点的值都大于它的左孩子，小于它的右孩子，提高检索效率

二叉树在生成过程的容易失衡，导致检索效率降低

平衡二叉树：是一颗空树，左右子树的高度差的绝对值不超过一，并且左右孩子都是一颗平衡二叉树

}

红黑树是一种平衡二叉树，要满足数据的平衡，二叉树要满足一下特点：

1、每个节点都只能是红色或者黑色

2、根节点必须都是黑色

3、叶子结点都必须是黑色的

4、如果一个节点时红色的，则它的子节点都是黑色的，一条路径上不能出现相邻的两个红色节点或黑色节点

5、从任意一个节点到其叶子节点包含相同数目的黑色节点

插入或者删除数据，红黑树就发生了变换，调整无非就是左旋，右旋，或者着色

2.3.3TreeMap源码分析

存储数据Entry节点：

static final class Entry<K,V> implements Map.Entry<K,V> {K key; //键V value; //值Entry<K,V> left = null;//左孩子Entry<K,V> right = null;//右孩子Entry<K,V> parent; //父节点boolean color = BLACK;//颜色//左孩子，右孩子，父节点，颜色（默认是black）Entry(K key, V value, Entry<K,V> parent) {this.key = key;this.value = value;this.parent = parent;}

比较器

private final Comparator<? super K> comparator;//比较器private transient Entry<K,V> root = null; //root属性，红黑树的根节点，是entry类型
entry节点根据key进行排序/*** The number of entries in the tree*/private transient int size = 0;  //存储数据数量

构造函数：

//默认的构造方法，comparator为null，按照key自然顺序来位置TreeMap的顺序
public TreeMap() {comparator = null;
}
//指定一个比较器来构造一个TreeMap
public TreeMap(Comparator<? super K> comparator) {this.comparator = comparator;
}
//
public TreeMap(Map<? extends K, ? extends V> m) {comparator = null;putAll(m);
}//构造一个sortmap的TreeMap，使用sortmap实例的构造器来实例TreeMap
public TreeMap(SortedMap<K, ? extends V> m) {comparator = m.comparator();try {buildFromSorted(m.size(), m.entrySet().iterator(), null, null);} catch (java.io.IOException cannotHappen) {} catch (ClassNotFoundException cannotHappen) {}
}

2.3.4treemap提供的方法：

2.4WeakHashMap

优化jvm，使GC更加智能的回收无用对象

weakhashmap关键是：当一个键对象被GC回收是，响应的值对象的引用从map中删除，weakhashmap能节约存储空间，来实现缓存那些非必要的数据

引用类型:

java中提供的引用类型有4种：强（Strong）引用,软（soft）引用，弱（weak）引用，虚（phantom）引用

2.4.1强引用：

常使用的引用类型，在创建对象时

Object o = new Object();

只要强引用存在，GC永远不会被回收引用的对象，通过new创建的对象所关联引用就是强引用，此时GC就不会碰该对象，当JVM内存空间不足，JVM宁愿抛出OOM(OutOfMemoryError)运行错误，使得程序终止，也 不会随时回收强引用所作用的对象

java中除了强引用还有三种引用，在java.lang.ref.Reference

2.4.2软引用：

内存不足就回收

2.4.3弱引用：

GC操作时就会被回收

2.4.4虚引用：

是最弱的引用关系，一个对象是否有虚引用的存在，不会影响对象的生命周期，虚引用存在的目的是当对象被回收时收到一个系统通知

java-集合框架库相关推荐

1. 【Java集合框架】ArrayList类方法简明解析（举例说明）

   本文目录 1.API与Java集合框架 2.ArrayList类方法解析 2.1 add() 2.2 addAll() 2.3 clear() 2.4 clone() 2.5 contains() 2 ...

2. Java集合框架之四大接口、常用实现类，java基础面试笔试题

   我总结出了很多互联网公司的面试题及答案,并整理成了文档,以及各种学习的进阶学习资料,免费分享给大家. 扫描二维码或搜索下图红色VX号,加VX好友,拉你进[程序员面试学习交流群]免费领取.也欢迎各位一起 ...

3. Java 集合框架系列，总结性全文，解决你所有困惑

   文章目录 集合接口 Collection Map 集合实现类 抽象类实现 通用实现 遗留实现 并发实现 特殊实现 适配器实现 包装器实现 便利实现 基础设施 算法和工具实现 定长/变长 可改/不可改 ...

4. Java集合框架综述，这篇让你吃透！

   点击上方"方志朋",选择"设为星标" 回复"666"获取新整理的面试文章 作者:平凡希 cnblogs.com/xiaoxi/p/60899 ...

5. Java集合框架的知识总结（1）

   Java集合框架的知识总结(1) 所有集合类都位于java.util包下.集合中只能保存对象(保存对象的引用变量). Java的集合类主要由两个接口派生而出:Collection和Map,Collec ...

6. java集合框架史上最详解（list set 以及map）

   title: Java集合框架史上最详解(list set 以及map) tags: 集合框架 list set map 文章目录 一.集合框架总体架构 1.1 集合框架在被设计时需满足的目标 1.2 ...

7. 【Java集合源码剖析】Java集合框架

   2019独角兽企业重金招聘Python工程师标准>>> Java集合工具包位于Java.util包下,包含了很多常用的数据结构,如数组.链表.栈.队列.集合.哈希表等.学习Java集 ...

8. Java集合框架中Map接口的使用

   在我们常用的Java集合框架接口中,除了前面说过的Collection接口以及他的根接口List接口和Set接口的使用,Map接口也是一个经常使用的接口,和Collection接口不同,Map接口并不 ...

9. java集合框架综述

   一.集合框架图 简化图: 说明:对于以上的框架图有如下几点说明 1.所有集合类都位于java.util包下.Java的集合类主要由两个接口派生而出:Collection和Map,Collection和 ...

10. java集合框架容器 java框架层级 继承图结构 集合框架的抽象类 集合框架主要实现类...

    本文关键词: java集合框架  框架设计理念  容器 继承层级结构 继承图 集合框架中的抽象类  主要的实现类 实现类特性   集合框架分类 集合框架并发包 并发实现类 什么是容器? 由一个或多个确 ...

最新文章

1. HttpContext.Current.Session ，出现未将对象引用设置到实例上
2. Vue中token刷新及token过期的实现
3. Java工作笔记-@Value注解的使用（可用于配置文件）
4. 微信小程序canvas保存绘制图片
5. ajax回显500因为#与$的原因
6. python 源码编译教程_python源码编译
7. 如何修改influxdb表结构_influxdb基本操作
8. winform 报表的基本使用
9. 上海电信中兴B860A 4K版破解
10. 嵌入式linux项目,嵌入式linux项目开发（一）
11. SpringCloud 问题杂集
12. Google play中下载apk
13. 国外数据挖掘方面的经典博客
14. 定制自己的股票量化分析工具QTYX-V2.0版-使用帮助
15. 题目7：猴子跳台阶 1级和3级
16. Ubuntu 重命名文件
17. 清华郑莉C++语言程序设计学习笔记（1）- 绪论、C++简单程序设计、函数
18. Android下的遥控器DIY
19. shell不允许输入空字符_Linux Cygwin知识库（一）：一文搞清控制台、终端、shell概念...
20. 以下选项中不是python对文件的写操作方法的是_以下选项中不是Python对文件的写操作方法的是:()-智慧树品三国，论领导艺术章节答案...

热门文章

1. 华为笔记本电脑真香，包邮送一台！
2. 机器学习基石(林軒田)笔记之十二
3. Excel 2010 VBA 入门 028 向单元格输入公式
4. html word 编辑表格,在Word文档中运用编辑表格的7个技巧
5. docker 常用命令 -----（批量查看镜像/容器，重命名，运行，进入容器，私有仓库）
6. JTopo添加动态连线
7. （小甲鱼python）集合笔记合集一 集合(上)总结 集合的简单用法 集合的各种方法合集：子、交、并、补、差、对称差集、超集
8. ABP——切换MySQL数据库
9. 共建计算产业，共创数智未来
10. Python--自动将文件分类归入文件夹