java list定义和使用-jquery定义list集合

在进行list列表元素迭代的时候，如果想要在迭代过程中，对元素进行操作的时候，比如满足条件添加或者移除元素。会发生ConcurrentModificationException并发修改异常[ˌmɒdɪfɪˈkeɪʃn]。

导致原因

集合引用和迭代器引用在同时操作元素，通过集合获取对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器不知道，所以不会出异常情况。

解决办法

既然是在迭代中对元素进行操作,找迭代器的方法最为合适.可是Iterator中只有hasNext,next,remove方法.通过查阅的它的子接口,ListIterator,发现该列表迭代器接口具备了对元素的增、删、改、查的动作。

List Iterator是List集合中特有迭代器

方法摘要

void

(Ee)将指定的元素插入列表（可选操作）。

boolean

()以正向遍历列表时，如果列表迭代器有多个元素，则返回true（换句话说，如果next返回一个元素而不是抛出异常，则返回true）。

boolean

()如果以逆向遍历列表，列表迭代器有多个元素，则返回true。

E

()返回列表中的下一个元素。

int

()返回对next的后续调用所返回元素的索引。

E

()返回列表中的前一个元素。

int

()返回对previous的后续调用所返回元素的索引。

void

()从列表中移除由next或previous返回的最后一个元素（可选操作）。

void

(Ee)用指定元素替换next或previous返回的最后一个元素（可选操作）。

数组和arrayList区别 Array的空间是大小固定的，空间不够时也能再次申请，所以需要事前确定合适的空间大小。ArrayList 的空间是动态增长的，如果空间不够，它会创建一个空间比原空间大0.5倍的新数组，然后将所有的元素复制到新数组中，接着抛弃旧数组。而且每次新添加的元素的时候都会检查内部数组的空间是否足够。 扩容方法system.copyOf()

public static native void System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);src - 源数组,srcPos - 源数组中的起始位置，dest - 目标数组，destPos - 目的地数据中的起始位置,Length - 要复制的源数组元素的数量。

ArrayList与LinkedList 区别

底层结构不同

ArrayList动态数组来存储元素，同事数组也属于顺序结构的线性表，逻辑上和物理上都是连续的。LinkedList双向链表来存储元素，可当做堆栈、队列、双端队列使用，逻辑上是连续的，但是物理（真是的内存上）上不一定连续。

ArrayList空间连续、支持随机访问。

1.中间或前面部分的插入删除时间复杂度O(N)

2.增容的代价比较大。

LInkedList以节点为单位存储，不支持随机访问。

任意位置插入删除时间复杂度为O(1)没有增容问题，插入一个开辟一个空间。

LinkedList(Node存储结构)比arrayList占空间.

arrayList

linkedList

vector

默认容量

10

双链表存储方式，对容量没有要求，不需要扩容

10

数据结构

动态数组

双向链表

扩容

原来1.5倍

插入更方便，随用随取

原来容的两倍

查询

下标查找O(1)

遍历查找值0(n)

遍历查找0(n)

O(1)

插入

尾部插入O(1)

头/中间插入O(n)数据移动

头插法O(1)

尾插法O(n) 遍历

修改

下标O(1)

值O(n)遍历

LInkedList没有下标O(n)

删除

O(n)数据移动；最后一个元素，时间复杂度为O(1)

头节点O(1)；

其他O(n)遍历

线程安全

synchronized

场景

通过下标直接查找/修改

添加/删除元素

不用移动数据

原文链接：

LinkedList和链表的区别

给定一个单向链表，删除最后一个节点，时间复杂度是O（N）

给定一个LinkedList,删除最后一个节点，时间复杂度为O（1）

基于链表可以存储在分散的内存中，适合做数据的插入及删除操作，不适合查询；需要逐一遍历。linkedList必须使用iteator不能使用for循环，因为每次for循环体get(i)取得某一元素时都需要对list重新进行遍历，性能消耗极大。另外不要视图使用indexOf等放回元素索引，并利用其遍历，使用indexOf对list进行遍历，当结果为空时会遍历整个列表。ArrayList 基于动态数组

连续内存存储，适合下标访问（随机访问），使用尾插法并指定初始化容量可以极大提升性能，甚至超过LinkedList（LinkedList需要创建大量的node对象）

扩容时机：如果当前数组大小大于数组初识容量（比如初识容量为10，当添加第11个元素时）就会进行扩容，新的容量为旧的容量的1.5倍

扩容方式：扩容时，会以新的容量创建一个原数组的拷贝，将原数组的数据拷贝过来，原数组会被GC回收。

优点：查找速度快、随机访问性强、尾插速度快，时间复杂为O（N）

缺点：1.头插、中间插入和删除操作时需要搬运数据，时间复杂度是O(N) 2.数组需要连续的内存空间，对空间要求高 3.数组是固定大小的，但是ArrayList 插入元素会触发扩容机制LinkedList 双向链表

java中的List接口(ArrayList、Vector、LinkedList) - 平凡晨 - 博客园

优点：1.内存利用率高，不会浪费内存

2.大小不固定，拓展灵活

3.插入、删除头尾速度快，时间复杂度为O（1）

缺点：LinkedList 中间位置插入元素，时间复杂度为O（N）,且不能随机查找，必须遍历链表

LinkedList 的双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

LinkedList增删快

原因：双向链表的数据结构java list定义和使用，只需要修改插入位置或删除位置左右数据的引用目标即可。

ArrayList查询快

底层是用的数组存储，数组的查询实际上是对引用地址的访问，不需要遍历。列如 new int arr[5];

增删慢（使用数组的弊端）

Java集合面试题（2021最新版） - 掘金

——Set接口

Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

|——HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；

HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。

当元素的hashCode值相同时，才继续判断元素的equals是否为true。

如果为true，那么视为相同元素，不存。如果为false，那么存储。

如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。

|——LinkedHashSet：有序，hashset的子类。

|——TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。

哈希表的原理：

1，对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值称为哈希值。

2，哈希值就是这个元素的位置。

3，如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础+1顺延。

4，存储哈希值的结构，我们称为哈希表。

5，既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。

这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。

对于ArrayList集合java list定义和使用，判断元素是否存在，或者删元素底层依据都是equals方法。

对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

TreeSet:

用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。

如果元素不具备比较性，在运行时会发生ClassCastException异常。

所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。

依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。

TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return0，视为两个对象重复，不存。

注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。

在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。

TreeSet集合排序有两种方式，Comparable和Comparator区别：

1：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法。

2：让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数。

第二种方式较为灵活。

Map集合

|——Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

|——HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

|——TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

Map集合存储和Collection有着很大不同：

Collection一次存一个元素；Map一次存一对元素。

Collection是单列集合；Map是双列集合。

Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

特点：要保证map集合中键的唯一性。

1，添加。

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

voidputAll(Map);

2，删除。

voidclear()：清空

valueremove(key)：删除指定键。

3，判断。

booleanisEmpty()：

booleancontainsKey(key)：是否包含key

booleancontainsValue(value)：是否包含value

4，取出。

intsize()：返回长度

valueget(key)：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

Collectionvalues()：获取map集合中的所有的值。

5，想要获取map中的所有元素：

原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

★把map集合转成set的方法：

SetkeySet();

SetentrySet();//取的是键和值的映射关系。

Entry就是Map接口中的内部接口；

为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

//取出map集合中所有元素的方式一：keySet()方法。
//可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
　　　　　　Set keySet = map.keySet();
　　　　　　Iterator it = keySet.iterator();
　　　　　　while(it.hasNext()) {
　　　　　　　　Object key = it.next();
　　　　　　　　Object value = map.get(key);
　　　　　　　　System.out.println(key+":"+value);
　　　　　　}
——————————————————————————————————————————————————————
//取出map集合中所有元素的方式二：entrySet()方法。
　　　　　　Set entrySet = map.entrySet();
　　　　　　Iterator it = entrySet.iterator();
　　　　　　while(it.hasNext()) {
　　　　　　　　Map.Entry  me = (Map.Entry)it.next();
　　　　　　　　System.out.println(me.getKey()+":"+me.getValue());
　　　　　　}
// lambda表达式forEach遍历
map.forEach((k, v) -> System.out.println("key = " + k + ", value = " + v));

Map集合都有哪些实现

HashTable/LinkedHashMap/TreeMap/ConcurrentHashMap/weakHashMap/EnumMap键是枚举类型

HashMap Key-value 数据结构，存取无序，键和值都可以为null,键是唯一的，非线程安全，默认容量为16，加载因子默认阈值0.75，底层采用Node数组+ 单链表结构(链表是解决hash冲突的拉链法)1.8后链表的深度大于8，且数组容量64时，扩容的时候会把链表转成红黑树，时间复杂度从O(n)变成O(logN);当红黑树的节点深度小于等于6时，红黑树会转为链表结构。【1亿个出现6个的概率转红黑树】

树的特点：短(深度)、旋转、查询快

扩容机制：2的次幂 （2,4，8 ，16,32,48）存储元素> 加载因子0.75 * 初始容量

1.7和1.8区别

1.7node数组加单链表，1.8后链表冲突多了红黑树；

1.7中新增节点采用头插法，

1.8中新增节点采用尾插法（避免逆序且链表死循环的问题）

Hash算法解决冲突

开放定址法：一旦发生了冲突，就去寻找下一个空的散列地址

再哈希法：多个不同的Hash函数，当发生冲突时，使用第二个，第三个，…。

建立公共溢出区：将哈希表分为基本表和溢出表两部分，凡是和基本表发生冲突的元素，一律填入溢出表

JDK1.7 HashMap线程不安全体现在：死循环、数据丢失

调用了HashMap#transfer()，具体原因：某个线程执行过程中，被挂起，其他线程已经完成数据迁移，等CPU资源释放后被挂起的线程重新执行之前的逻辑，数据已经被改变，造成死循环、数据丢失

JDK1.8 HashMap线程不安全体现在：数据覆盖

线程A、B都在进行put操作，并且hash函数计算出的插入下标是相同的，A被挂起(由于时间片耗尽导致)，b插入成功。之前A已经进行了hash碰撞，所有不会再进行判断。直接插入就数据覆盖了。

链表查询的时间复杂度为O(n)，红黑树查询的时间理想情况o(1)，最坏复杂度为O(logn）

多线程使用hashmap

Collections.synchronizedMap(Map)创建线程安全的map集合

Hashtable

ConcurrentHashMap：性能和效率好

put流程

1.接受传入的参数，通过key计算hash值，得到数组下标位置；未发生hash碰撞，直接插入结束；发生hash碰撞，走第2步；

2.判断key是否相等如果等于直接替换，否则判断当前数据节点是红黑树还是链表，如果是链表，将数据放入链表头节点，原数据往后移；如果是红黑树，走第3步；

3.直接在红黑树插入数据结束；

hash():计算对应的位置

resize():扩容

putTreeVal():树形节点的插入

treeifyBin():树形化容器

具体

对key的hashCode()做hash运算，计算index;.如果没碰撞直接放到bucket⾥；如果碰撞了，以链表的形式存在buckets后；如果碰撞导致链表过⻓(⼤于等于8且数据大于64)，就把链表转换成红⿊树(JDK1.8中的改动)；如果节点已经存在就替换old value(保证key的唯⼀性)如果bucket满了(超过load factor*current capacity)，就要resize

get流程

1.对key的hashCode()做hash运算，计算index;

2.如果在数组⾥的第⼀个节点⾥直接命中，则直接返回；

3.如果有冲突，则通过key.equals(k)去查找对应的桶;

4. 若为树，则在树中通过key.equals(k)查找，O(logn)；

5. 若为链表，则在链表中通过key.equals(k)查找，O(n)。

HashMap底层实现原理及扩容机制 - dadapeng - 博客园

【大厂面试题系列】：JDK7、8 HashMap的get()、put()方法流程_Code皮皮虾的博客-CSDN博客

HashMap面试必问的6个点，你知道几个？ - 掘金

Hahmap vs HashTable

HashTable(全表锁)

get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问的时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞。

TreeMap

存储结构是一个平衡二叉树，具体实现方式为红黑树，默认采用自然排序，会发现其默认采用key由小到大的顺序输出键值对。适用于按照自然排序和自定义排序规则，

LinkedHashMap

linkedHashMap最大的特点在于有序，但是它的有序主要体现在先进先出FIFIO上。没错，主要依靠双向链表和hash表来实现的。哈希表保证键唯一，链表保证键有序

ConcurrentHashMap

Hashmap key value 可以为空;ConcurrentHashMap key value 不可以为空(put 有校验，防止出现线程问题)

1.7 分段锁：默认的segment是一个数组，默认长度为16。也就是说理论上可以提高16倍的性能。

HashMap,LinkedHashMap,TreeMap的区别（转） - 贾树丙 - 博客园

weakHashMap

它是一个“弱键”，它的Key值和Value都可以是null，而且其Map中如果这个Key值指向的对象没被使用，此时触发了GC，该对象就会被回收掉的。

其原理主要是使用的WeakReference和ReferenceQueue实现的，其key就是weakReference，而ReferenceQueue中保存了被回收的 Key-Value。

原文链接：java中Map有哪些实现类和使用场景_逐风的小黄的博客-CSDN博客_map的实现类有哪些

红黑树 与 B+树区别和应用场景

红黑树其实就是平衡树的一种，复杂的定义和规则，最后都是为了保证树的平衡性。

因为树的查找性能取决于树的高度，让树尽可能平衡，就是为了降低树的高度。

B树常用在文件系统的索引上，那为什么文件索引喜欢用B树而不是红黑树呢？

因为文件系统和数据库的索引都是存在硬盘上的，并且如果数据量大的话，不一定能一次性加载到内存。

所以一棵树都无法一次性加载进内存，又如何谈查找。所以B树的多路存储能力就出来了，可以每次加载B树的一个节点，然后一步步往下找。

那为什么要设计成多路呢？

是为了进一步的降低树的高度，路数越多，树的高度就越低

所以，如果实在内存中，红黑树比B树的效率更高，但涉及到磁盘操作，B树就更优了。

B树的基础上基础上进行改造，它的数据都在叶子节点，同时叶子节点之间还加了指针形成链表*

为什么要这么设计呢？

这也是和业务场景相关的，你想想，数据库中 Select 数据，不一定只选一条，很多时候会选多条，比如按照 ID 排序后选 10 条。如果是多条的话，B树需要做局部的中序遍历，可能还要跨层访问，而B+树由于所有数据都在叶子节点，不用跨层，同时由于有链表结构，只需要找到首尾，通过链表就能把所有数据取出来了。

场景：红黑树java中TreeMap，jdk1.8的hashmap的实现。B树:常用在文件系统的索引上。b+树 ：mysql索引。

红黑树,B树,B+树 本质区别_Linias的博客-CSDN博客_b+树和红黑树的区别

总结 使用集合的技巧

看到Array就是数组结构，有角标，查询速度快。

看到Link就是链表结构：增删速度快，而且有特定方法。addFirst() 、addLast() 、removeFirst()、removeLast()、getFirst()、getLast()。

看到hash就是哈希表：就是想要哈希值，就是想到唯一性，就是想到存入到该数据结构中的元素覆盖hashCode、equals方法。

看到Tree口就是二叉树，就要想到排序，就想要用到比较。

比较两种方式

comparable : 覆盖compareTo 方法；comparator: 覆盖compare方法。

LinkedHashSet、LinkedHashMap：这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表的有序。

集合什么时候用

当存储的是一个元素时，就用collection。当存储对象之间存在着映射关系时，就是用Map集合。

保证唯一就用Set,不保证唯一就用List。

Collections

它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

静态方法：

Collections.sort(list); 对list集合进行元素的自然顺序排序

Collections.max(list); 返回list集合中字段顺序最大的元素。

int index = Collections.binarySearch(list,"zz"); 二分查找，返回角标

Collection.reverseOrder(); 逆向返回反转排序。

Collections.shuffle(list); 随机对list中的元素进行位置的置换。

将非同步集合转成同步集合的方法：Collections中的 xxx synchronizeXXX(XXX);

List synchronizeList(list); Map synchronizeMap(map);

原理：定义一个类，将集合所有的方法加用一把锁返回。

Collection和Collections的区别

Collection是java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List，提供了关于集合的一些操作，如插入、删除、判断一个元素是否是其成员、遍历等。

Collections是java.util下的类，是针对集合类的一个工具类，提供一系列静态方法，实现对集合的查找、排序、替换、线程安全化(将非同步的集合转换成同步的)等操作。

Arrays

用于操作数组对象的工具类，里面都是静态方法。

asList方法: 将数组转换list集合。

String [] array = {"a","b","c"};

List list =array.asList(); //将array数组传换成集合

将数组转换成集合，有什么好处？用asList方法，将数组变成集合

可以通过list集合中的方法来操作数组中的元素：isEmpty() 、contains()、indexOf、set；

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如：add、remove、clear.会报不支持操作异常UnsupportedOperationException

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。

如果数组中存储的基本数据类型，asList会将数组实体作为集合元素存在。

集合变数组：用collection接口中的方法：toArray();

如果给toArray传递的指定类型的数据长度小于集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。

如果传递的指定的类型的数组的长度大于了集合色size,那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。

将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要回去这些元素即可。

增强for 循环：foreach语句，foreach简化了迭代器

格式：增强for 循环 括号里面写两个参数，第一个声明一个变量，第二个就是需要迭代的容器

for (元素类型 变量名：Collection集合& 数组）{

...

}

高级for循环和传统for循环区别：

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果是遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取可以简化成高级for循环，它的出现就是为了简写。

高级for循环可以遍历map集合吗？ 不可以，但是可以将map转成set在使用foreach语句。

作用：对存储对象的容器进行迭代：数组 collection map

增强for循环迭代数组:

//数组的静态定义方式，只使用于数组首次定义的时候    
 String []  array  = {"a","b","c"};     
for （String  str : array){
      Sysem.out.printIn(str);
}

单列集合collection

List  list = new  ArrayList();
list.add("A");
//增强for循环，没有使用泛型集合能不能使用增强for循环迭代？能
for (Objcet  object:list){
    String  str=(String) obj;
    System.out.println(str);
}

双列集合Map

Map map = new HashMap();
map.put("A","a");
//传统方式
//获取所有的键值对Entry对象
Set  entrys =map.entrySet();
//迭代出所有的entry
iter=entrys.iterator();
while(iter.hasNext()){
    Map.Entry enrty=(String) iter.next();
    //分别获取key和value
    String key =(String) entry.getkey();
    String value=(String) entry.getValue();
}

增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现Iterable接口的集合进行迭代；Iterator是jdk5中信定义的接口，就是一个方法iterator方法，只有实现了iterable接口的类，才能保证一定有Iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上我们可以用过某种方式实现增强的for循环。

for (Object object :map.entrySet()){
    Map.Entry entry = (Entry) object;
    System.out.println(entry.getkey()+"-"+entry.getValue());
}

集合迭代注意问题

在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类list Iterator:有增删的方法）。

增强for循环注意问题

int [] array = {1,2,3};
for(int num : array){
    num = 0;  //不能改变数组的值
}
//2
System.out.println(array[1]);

可变参数{......}:用到函数的参数上，当要操作的同一个类型元素个数不确定，可以用这个方式，这个参数可以接受个数的同一类型的数据。

和以前接收数组不一样的是：

以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，在底层完成的好，被隐藏了。所以简化了用户的书写，少了调用者定义参数的动作。

如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结构（也就是必须是最后一个参数，否则编译会失败）。

集合

结构

安全

方法

List有序

ArrayList

动态数组10

LinkedList

双向链表

Vector

动态数组10

synchronized

Stack

stack继承vector

后进先出的堆栈

push（压入）

pop（弹出）

peek（得到栈顶元素）

empty（判空）

search（检测一个元素在堆栈中的位置）

set无序去重

HashSet

集合的元素可以为null

TreeSet

TreeSet是SortedSet接口的实现类，可以保证元素处于排序状态，采用红黑树的数据结构存储集合元素

LinkedHashSet

是HashSet的子类，具有HashSet的特性，它使用链表维护元素的添加顺序，因此性能低于HashSet，便于迭代访问

EnumSet

专为枚举类设计的集合类，不允许添加null，集合元素有序

Queue消息阻塞队列

Deque双端队列

支持在两端插入和移除元素

PriorityQueue优先队列

优先级堆的无界优先级队列;

优先级队列不允许使用null元素

Map无序的存储

HashMap

Node数组+ 单链表结构(链表是解决hash冲突的拉链法)+红黑树

TreeMap

SortedMap的是实现类，与TreeSet一样使用红黑树的数据结构，每个作为红黑树的一个节点，通过k对节点进行排序

Hashtable

synchronized

ConcurrentHashMap

Cas+node数组synchronize

synchronized

Properties

是HashTable的子类，它是一个K和V都是String类型的Map,主要用于配置文件的读取

LinkedHashMap

是HashMap的子类，使用双向链表来维护Key-Value对插入的次序，在迭代访问时有较好的性能

weakHashMap

它是一个“弱键”，它的Key值和Value都可以是null，而且其Map中如果这个Key值指向的对象没被使用，此时触发了GC，该对象就会被回收掉的。