java容器01（List、Set、Map）

Java容器

1.常用的容器

List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
Collection接口下还有个Queue接口，有PriorityQueue类

Connection接口:
— List 有序,可重复

ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高
—Set 无序,唯一

HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()

LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一

TreeSet
底层数据结构是红黑树。(唯一，有序)

1. 如何保证元素排序的呢?
   自然排序
   比较器排序
   2.如何保证元素唯一性的呢?
   根据比较的返回值是否是0来决定

针对Collection集合我们到底使用谁呢?(掌握)

唯一吗?

​ 是：Set

​ 排序吗?

​ 是：TreeSet或LinkedHashSet
​ 否：HashSet
​ 如果你知道是Set，但是不知道是哪个Set，就用HashSet。

​ 否：List

​ 要安全吗?

​ 是：Vector
​ 否：ArrayList或者LinkedList

​ 查询多：ArrayList
​ 增删多：LinkedList
​ 如果你知道是List，但是不知道是哪个List，就用ArrayList。

2.Collection和Collections有什么区别

java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
Collections 则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

3.List

ArrayList

​ ArrayList作为List的典型实现，完全实现了List的全部接口功能，它是基于数组实现的List类，它封装了一个Object[]类型的数组，长度可以动态的增长。

​ 如果在创建ArrayList时没有指定Object[]数组的长度，它默认创建一个长度为10的数组，当新添加的元素已经没有位置存放的时候,ArrayList就会自动进行扩容，扩容的长度为原来长度的1.5倍。它的线程是不安全的。

在没有扩容操作的情况下，整个过程如下

若指定位置不在数组末尾时的删除过程如下：

遍历方式

List<String> list = new ArrayList<>() ;

//第一种
for (int i = 0; i < list.size(); i++) {
    list.get(i);
}
//第二种
for (Iterator iter = list.iterator(); iter.hasNext(); ) {
    iter.next();
}
//第三种
for (Object obj : list)
            ;

//第四种 ， 只支持JDK1.8+
list.forEach(
                e->{
                    ;
                }
        );

总结
ArrayList是基于数组实现的List类。会自动的进行扩容，采用Arrays.copyOf()实现
如果在创建ArrayList时，可以知道ArrayList元素的数量最好指定初始容量，这样可以避免ArrayList的自动多次扩容问题。
与 LinkedList 相比，ArrayList 适用于频繁查询的场景，而不适用于频繁修改的场景； 与 Vector 相比，ArrayList 的所有操作都是非线程安全的。
线程不安全

LinkedList

1.LinkedList是基于双向循环链表实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。
2.LinkedList同样是非线程安全的，只在单线程下适合使用。
3.LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。

单向链表

单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。

单向循环列表

单向循环链表和单向列表的不同是，最后一个节点的next不是指向null，而是指向head节点，形成一个“环”。

双向链表

从名字就可以看出，双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的next指向null。

双向循环链表

双向循环链表和双向链表的不同在于，第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。而LinkedList就是基于双向循环链表设计的。

ArrayList、LinkedList、Vector三者的区别

List常用的是 ArrayList和LinkedList

ArrayList底层使用的是数组 LinkedList使用的是链表。

1. 数组查询具有索引，查询特定元素比较快，而插入和删除和修改比较慢（数组在内存中会是一块连续的内存，如果插入或删除是需要移动内存）

2. 链表不要求内存是连续的 在当前元素中存放下一个或上一个元素的地址，查询时需要从头部开始，一个一个找，所以查询效率低，插入时不需要移动内存，只需改变引用指向即可，所以插入或者查询的效率高。

存储结构

ArrayList和Vector是按照顺序将元素存储（从下表为0开始），删除元素时，删除操作完成后，需要使部分元素移位，默认的初始容量都是10.

ArrayList和Vector是基于数组实现的，LinkedList是基于双向链表实现的（含有头结点）。

线程安全性能

ArrayList不具有有线程安全性，在单线程的环境中，LinkedList也是线程不安全的，如果在并发环境下使用它们，可以用Collections类中的静态方法synchronizedList(）对ArrayList和LinkedList进行调用即可。

Vector实现线程安全的，即它大部分的方法都包含关键字synchronized,但是Vector的效率没有ArraykList和LinkedList高。

扩容机制

从内部实现机制来讲，ArrayList和Vector都是使用Object的数组形式来存储的，当向这两种类型中增加元素的时候，若容量不够，需要进行扩容。ArrayList扩容后的容量是之前的1.5倍，然后把之前的数据拷贝到新建的数组中去。而Vector默认情况下扩容后的容量是之前的2倍。

Vector可以设置容量增量，而ArrayList不可以。在Vector中，有capacityIncrement：当大小大于其容量时，容量自动增加的量。如果在创建Vector时，指定了capacityIncrement的大小，则Vector中动态数组容量需要增加时，如果容量的增量大于0，则增加的是大小是capacityIncrement，如果增量小于0，则增大为之前的2倍。

在这里需要说一下可变长度数组的原理：当元素个数超过数组的长度时，会产生一个新的数组，将原数组的数据复制到新数组，再将新的元素添加到新数组中。

增删改查的效率

ArrayList和Vector中，从指定的位置检索一个对象，或在集合的末尾插入、删除一个元素的时间是一样的，时间复杂度都是O（1）。但是如果在其他位置增加或者删除元素花费的时间是O（n）,LinkedList中，在插入、删除任何位置的元素所花费的时间都是一样的，时间复杂度都为O（1），但是他在检索一个元素的时间复杂度为O（n）.

所以如果只是查找特定位置的元素或只在集合的末端增加移动元素，那么使用ArrayList或Vector都是一样的。如果是在指定位置的插入、删除元素，最好选择LinkedList

使用场景：

ArrayList使用在查询比较多，但是插入和删除比较少的情况，而LinkedList使用在查询比较少而插入和删除比较多的情况

4.Set

特点: 无序(没有下标)，不重复

HashSet

hashset具有去重功能，例: 创建一个hashset 保存 f f a a b b d d

HashSet<String> set = new HashSet<>();
set.add("f"); 
set.add("f");
set.add("a");
set.add("a");
set.add("b");
set.add("b");
set.add("d");
set.add("d");
// 增强for循环
for (String string : set) {
	System.out.println(string);
}
打印结果 a b d f 
去重且无序(不是按照输出顺序打印)

HashSet实际上是一个HashMap实例，都是一个存放链表的数组。它不保证存储元素的迭代顺序；此类允许使用null元素。HashSet中不允许有重复元素，这是因为HashSet是基于HashMap实现的，HashSet中的元素都存放在HashMap的key上面，而value中的值都是统一的一个固定对象private static final Object PRESENT = new Object();

HashSet中add方法调用的是底层HashMap中的put()方法，而如果是在HashMap中调用put，首先会判断key是否存在，如果key存在则修改value值，如果key不存在这插入这个key-value。而在set中，因为value值没有用，也就不存在修改value值的说法，因此往HashSet中添加元素，首先判断元素（也就是key）是否存在，如果不存在这插入，如果存在着不插入，这样HashSet中就不存在重复值。

所以判断key是否存在就要重写元素的类的equals()和hashCode()方法，当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算次对象的哈希值，此哈希值决定了此对象在Set中存放的位置；若此位置没有被存储对象则直接存储，若已有对象则通过对象所在类的equals()比较两个对象是否相同，相同则不能被添加。

LinkedHashSet

1. LinkedHashSet概述：

LinkedHashSet是具有可预知迭代顺序的Set接口的哈希表和链接列表实现。此实现与HashSet的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可为插入顺序或是访问顺序。

注意，此实现不是同步的。如果多个线程同时访问链接的哈希Set，而其中至少一个线程修改了该Set，则它必须保持外部同步。

2. LinkedHashSet的实现：

对于LinkedHashSet而言，它继承与HashSet、又基于LinkedHashMap来实现的。

LinkedHashSet底层使用LinkedHashMap来保存所有元素，它继承与HashSet，其所有的方法操作上又与HashSet相同，因此LinkedHashSet 的实现上非常简单，只提供了四个构造方法，并通过传递一个标识参数，调用父类的构造器，底层构造一个LinkedHashMap来实现，在相关操作上与父类HashSet的操作相同，直接调用父类HashSet的方法即可。

TreeSet

TreeSet用来排序

创建一个TreeSet 添加几个数 查看效果

TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(66);
treeSet.add(66);
treeSet.add(22);
treeSet.add(77);
treeSet.add(11);
treeSet.add(11);
System.out.println(treeSet);

输出结果为：[11, 22, 66, 77]
输出结果自动去重排序

TreeSet的两种排序方式比较

1.排序的引入(以基本数据类型的排序为例)

public class MyClass {
    public static void main(String[] args) {
        // 创建集合对象
        // 自然顺序进行排序
        TreeSet<Integer> ts = new TreeSet<Integer>();
        // 创建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);
        // 遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}
运行结果:
17
18
19
20
22
23
24

2.如果是引用数据类型呢,比如自定义对象,又该如何排序呢?

由于不知道该安照那一中排序方式排序，所以会报错。
解决方法：

1.自然排序：类中实现 Comparable接口，重写Comparable接口中的Compareto方法

2.比较器排序：单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口。重写Comparator接口中的Compare方法

TreeSet, LinkedHashSet and HashSet 的区别

1. 介绍

TreeSet, LinkedHashSet and HashSet 在java中都是实现Set的数据结构
TreeSet：的主要功能用于排序
LinkedHashSet：的主要功能用于保证FIFO即有序的集合(先进先出)
HashSet：只是通用的存储数据的集合

2. 相同点

1、Duplicates elements 复制元素: 因为三者都实现Set interface，所以三者都不包含duplicate elements
2、线程安全: 三者都不是线程安全的，如果要使用线程安全可以Collections.synchronizedSet()

3. 不同点

1、性能和速度: HashSet插入数据最快，其次LinkHashSet，最慢的是TreeSet因为内部实现排序
2、有序: HashSet不保证有序，LinkHashSet保证FIFO即按插入顺序排序，TreeSet安装内部实现排序，也可以自定义排序规则
3、为空 :HashSet 和LinkHashSet 允许存在null数据，但是TreeSet中插入null数据时会报NullPointerException

代码比较：

  public static void main(String args[]) {
        HashSet<String> hashSet = new HashSet<>();
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        TreeSet<String> treeSet = new TreeSet<>();

        for (String data : Arrays.asList("B", "E", "D", "C", "A")) {
            hashSet.add(data);
            linkedHashSet.add(data);
            treeSet.add(data);
        }
        //不保证有序
        System.out.println("Ordering in HashSet :" + hashSet);
        //FIFO保证安装插入顺序排序
        System.out.println("Order of element in LinkedHashSet :" + linkedHashSet);
        //内部实现排序
        System.out.println("Order of objects in TreeSet :" + treeSet);
    }

运行结果:
Ordering in HashSet :[A, B, C, D, E] (无顺序)
Order of element in LinkedHashSet :[B, E, D, C, A] (FIFO插入有序)
Order of objects in TreeSet :[A, B, C, D, E] (排序)

5.Map

Hashmap

hashmap的底层数据结构散列表，即：数组+链表，创建的时候初始化一个数组，每个节点可以为一个链表

map.put(k,v)实现原理：

​ 第一步：首先将k,v封装到Node对象当中（节点）。

​ 第二步：它的底层会调用K的hashCode()方法得出hash值。
​ 第三步：通过哈希表函数/哈希算法，将hash值转换成数组的下标，下标位置上如果没有任何元素，就把Node添加到这个位置上。

​ 如果说下标对应的位置上有链表。此时，就会拿着k和链表上每个节点的k进行equal。
​ 如果所有的equals方法返回都是false，那么这个新的节点将被添加到链表的末尾。如其中有一个equals返回了true，那么这个节点的value将会被覆盖。
map.get(k)实现原理：

​ 第一步：先调用k的hashCode()方法得出哈希值，并通过哈希算法转换成数组的下标。
​ 第二步：通过上一步哈希算法转换成数组的下标之后，在通过数组下标快速定位到某个位置上。重点理解如果这个位置上什么都没有，则返回null。
​ 如果这个位置上有单向链表，那么它就会拿着参数K和单向链表上的每一个节点的K进行equals，
​ 如果所有equals方法都返回false，则get方法返回null。
​ 如果其中一个节点的K和参数K进行equals返回true，
​ 那么此时该节点的value就是我们要找的value了，get方法最终返回这个要找的value。

Hashtable：

​ Hashtable与HashMap类似，是HashMap的线程安全版，它支持线程的同步，即任一时刻只有一个线程能写Hashtable，因此也导致了Hashtale在写入时会比较慢。
​ 它继承自Dictionary类，不同的是它不允许记录的键或者值为null，同时效率较低。

LinkedHashMap：

​ LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢，有HashMap的全部特性。

TreeMap：

​ 基于红黑二叉树的NavigableMap的实现，线程非安全，不允许null，key不可以重复，value允许重复，存入TreeMap的元素应当实现Comparable接口或者实现Comparator接口，
​ 会按照排序后的顺序迭代元素，两个相比较的key不得抛出classCastException。
​ 主要用于存入元素的时候对元素进行自动排序，迭代输出的时候就按排序顺序输出

6.区别

arraylist和linkedlist

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 这一点要看实际情况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。

HashMap与TreeMap

1、 HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

2、在Map 中插入、删除和定位元素，HashMap是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和 equals()的实现。

两个map中的元素一样，但顺序不一样，导致hashCode()不一样。

同样做测试：
　　　　在HashMap中，同样的值的map,顺序不同，equals时，false;
　　　　而在treeMap中，同样的值的map,顺序不同,equals时，true，说明，treeMap在equals()时是整理了顺序了的。

HashTable与HashMap

1、同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。

2、HashMap允许存在一个为null的key，多个为null的value 。

3、hashtable的key和value都不允许为null。

说一下 HashSet 的实现原理？

• HashSet底层由HashMap实现
• HashSet的值存放于HashMap的key上
• HashMap的value统一为PRESENT

ArrayList 和 Vector 的区别是什么？

Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。
ArrayList比Vector快，它因为有同步，不会过载。
ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。

Array 和 ArrayList 有何区别？

Array可以容纳基本类型和对象，而ArrayList只能容纳对象。
Array是指定大小的，而ArrayList大小是固定的。
Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。

哪些集合类是线程安全的？

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。
statck：堆栈类，先进后出。
hashtable：就比hashmap多了个线程安全。
enumeration：枚举，相当于迭代器。

迭代器 Iterator 是什么？

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

Iterator 怎么使用？有什么特点？

Java中的Iterator功能比较简单，并且只能单向移动：

(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

(2) 使用next()获得序列中的下一个元素。

(3) 使用hasNext()检查序列中是否还有元素。

(4) 使用remove()将迭代器新返回的元素删除。

Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

Iterator 和 ListIterator 有什么区别？

Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。