1. Map和collection的继承关系

map和collection的继承关系和子类用法以及线程安全问题

一、Map

1. map的定义

1. Map本身是一个接口，要使用Map需要通过子类进行对象实例化。

    接口不可以实例化。
   

public interface Map<K, V> {
}

2. Map接口的常用子类有如下四个：HashMap、HashTable、TreeMap、ConcurrentHashMap。
3. AbstractMap和SortedMap直接继承自map

//AbstractMap抽象类
public abstract class AbstractMap<K,V> implements Map<K,V> {
}

//SortedMap接口
public interface SortedMap<K,V> extends Map<K,V> {
}

2. HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
}

1. HashMap 数据结构为 数组+链表，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性（hash，key，value，next）

    整体是一个数组；
    数组每个位置是一个链表；
    链表每个节点中的Value即我们存储的Object；
   

2. HashMap中key和value都允许为 null key不可以重复。

3. HashMap的方法不是同步的，线程是不安全的。

3. HashTable

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
}

1. HashTable数据结构为 数组+链表。
2. HashTable 中 key和 value都不允许为 null。
3. HashTable 的方法是同步的，线程是安全的。

4. TreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable{
}

1. TreeMap是一个典型的基于红黑树的Map实现，因此它要求一定要有Key比较的方法，要么传入Comparator实现，要么key对象实现Comparable接口。
2. TreeMap是非线程安全的 。

5. ConcurrentHashMap

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
}

1. ConcurrentHashMap的数据结构为 数组+链表。
2. ConcurrentHashMap 采用了分段锁技术。
3. ConcurrentHashMap 是 Java 并发包中提供的一个线程安全且高效的 HashMap 实现。

二、collection

public interface Collection<E> extends Iterable<E> {
}

1. Collection 接口有 3 种子类型集合: List、Set 和 Queue，
2. 常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、ArrayBlockingQueue。

List 接口

public interface List<E> extends Collection<E> {
}

Set 接口

public interface Set<E> extends Collection<E> {
}

Queue 接口

public interface Queue<E> extends Collection<E> {
}

1. ArrayList

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

① 特点

1. 特点： 有序、不唯一
2. 底层基于数组实现容量大小动态变化。
3. 允许 null 的存在。
4. 线程不安全

② 常用方法

1. 添加元素 list.add(元素);
2. 得到集合元素的个数 list.size();
3. 得到某一个元素 list.get(下标);
4. 如何判断集合里面是否出现指定元素 list.contains();
5. 删除元素 list.remove(int 下标);
6. 清空集合：list.clear();
   原文链接：https://blog.csdn.net/sukelys/article/details/103395232

2. LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
}

1. LinkedList底层通过双向链表实现，双向链表的每个节点用内部类Node表示。
2. LinkedList通过first和last引用分别指向链表的第一个和最后一个元素。
3. 线程不安全

3. HashSet

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable{
}

① 特点

1. HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。
2. HashSet 允许有 null 值。
3. HashSet 是无序的，即不会记录插入的顺序。
4. 由于是无序的所以每组数据都没有索引，很多list可用的方法他都没有
5. HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。
6. 凡是需要通过索引来进行操作的方法都没有，所以也不能使用普通for循环来进行遍历，只有加强型for和迭代器两种遍历方法
7. HashSet 实现了 Set 接口。
8. 原文链接：https://blog.csdn.net/weixin_43314519/article/details/107473290

② 常用方法

1. add(Object obj)：向Set集合中添加元素，添加成功返回true，否则返回false。
   add()如果此 set 中尚未包含指定元素，则添加指定元素。如果此Set没有包含满足(enull ? e2null : e.equals(e2)) 的e2时，则将e2添加到Set中，否则不添加且返回false。由于底层使用HashMap的put方法将key = e，value=PRESENT构建成key-value键值对，当此e存在于HashMap的key中，则value将会覆盖原有value，但是key保持不变，所以如果将一个已经存在的e元素添加中HashSet中，新添加的元素是不会保存到HashMap中，所以这就满足了HashSet中元素不会重复的特性。
2. size()：返回此set中的元素的数量（set的容量）。底层实际调用HashMap的size()方法返回Entry的数量，就得到该Set中元素的个数,即HashMap容器的大小。
3. remove(Object obj)： 删除Set集合中的元素，删除成功返回true，否则返回false。remove()如果指定元素存在于此 set 中，则将其移除。底层使用HashMap的remove方法删除指定的Entry。
4. isEmpty()：isEmpty()判断HashSet()集合是否为空，如果此set不包含任何元素，则返回true。 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。
5. clear()： 移除此Set中的所有元素。clear()从此 set 中移除所有元素。底层调用HashMap的clear方法清除所有的Entry。
6. == iterator()==：iterator()方法 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。底层实际调用底层HashMap的keySet来返回所有的key。 可见HashSet中的元素，只是存放在了底层HashMap的key上， value使用一个static final的Object对象标识。
7. contains(Object o)：contains()，判断某个元素是否存在于HashSet()中，存在返回true，否则返回false。更加确切的讲应该是要满足这种关系才能返回true：(onull ? enull : o.equals(e))。底层调用containsKey判断HashMap的key值是否为空。
   原文链接：https://blog.csdn.net/qq_43273025/article/details/107746856

3. LinkedHashSet

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
}

1. 底层是一个哈希表（数组+链表/红黑树）
2. LinkedHashSet 有序、线程不安全

4. ArrayBlockingQueue

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {
}

1. ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。
2. ArrayBlockingQueue线程安全

三、继续关系图