Java集合比较整理

Java集合比较整理

1:集合
    Collection(单列集合)
        List(有序,可重复)
            ArrayList
                底层数据结构是数组,查询快,增删慢
                线程不安全,效率高
            Vector
                底层数据结构是数组,查询快,增删慢
                线程安全,效率低
            LinkedList
                底层数据结构是链表,查询慢,增删快
                线程不安全,效率高
        Set(无序,唯一)
            HashSet
                底层数据结构是哈希表。
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可
                    
                LinkedHashSet
                    底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。
            TreeSet
                底层数据结构是红黑树。(是一种自平衡的二叉树)
                如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口
                        比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象
    Map(双列集合)
        A:Map集合的数据结构仅仅针对键有效，与值无关。
        B:存储的是键值对形式的元素，键唯一，值可重复。
        
        HashMap
            底层数据结构是哈希表。线程不安全，效率高
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可
            LinkedHashMap
                底层数据结构由链表和哈希表组成。
                    由链表保证元素有序。
                    由哈希表保证元素唯一。
        Hashtable
            底层数据结构是哈希表。线程安全，效率低
                哈希表依赖两个方法：hashCode()和equals()
                执行顺序：
                    首先判断hashCode()值是否相同
                        是：继续执行equals(),看其返回值
                            是true:说明元素重复，不添加
                            是false:就直接添加到集合
                        否：就直接添加到集合
                最终：
                    自动生成hashCode()和equals()即可
        TreeMap
            底层数据结构是红黑树。(是一种自平衡的二叉树)
                如何保证元素唯一性呢?
                    根据比较的返回值是否是0来决定
                如何保证元素的排序呢?
                    两种方式
                        自然排序(元素具备比较性)
                            让元素所属的类实现Comparable接口
                        比较器排序(集合具备比较性)
                            让集合接收一个Comparator的实现类对象
    




---------------------------------------


Collection接口：


1.Collection 和 Collections的区别：


·Collection: 是集合类的上层接口。本身是一个Interface，里面包含了一些集合的基本操作。 


Collection接口是Set接口和List接口的父接口。


·Collections: 是一个集合框架的帮助类，里面包含一些对集合的排序，搜索以及序列化的操作。


    最根本的是Collections是一个类哦。


2.
Collection<--List<--Vector
    Collection<--List<--ArrayList
    Collection<--List<--LinkedList
    Collection<--Set<--HashSet
    Collection<--Set<--HashSet<--LinkedHashSet
    Collection<--Set<--SortedSet<--TreeSet


---------------------------------------


java.lang.String.contains() 方法返回true，当且仅当此字符串包含指定的char值序列。


---------------------------------------


Set接口：


数组大小是固定的，只能放同一种类型。


无序的，不能使重复的元素。


HashSet、TreeSet、HashCode（hashcode）、LinkedHashSet


HashSet：


·HashSet是非同步的。


·HashSet允许使用 null 元素。


·HashSet继承于AbstractSet，并且实现了Set接口。


·HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序；


特别是它不保证该顺序恒久不变。此类允许使用null元素。


·对于HashSet而言，它是基于HashMap实现的，HashSet底层使用HashMap来保存所有元素，因此HashSet 


的实现比较简单，相关HashSet的操作，基本上都是直接调用底层HashMap的相关方法来完成。


·当我们试图把某个类的对象当成HashMap的key，或试图将这个类的对象放入HashSet中保存时,重写该类的


equals(Objectobj方法和hashCode）方法很重要，而且这两个方法的返回值必须保持一致：当该类的两个的 


hashCode() 返回值相同时，它们通过 equals() 方法比较也应该返回 true。通常来说，所有参与计算 


hashCode() 返回值的关键属性，都应该用于作为 equals() 比较的标准。






hashCode：

·如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。


·如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。


·理清了上面的关系我们就知道他们两者是如何配合起来工作的。


整个处理流程是：


1、判断两个对象的hashcode是否相等，若不等，则认为两个对象不等，完毕，若相等，则比较equals。


2、若两个对象的equals不等，则可以认为两个对象不等，否则认为他们相等。


TreeSet：


·一个有序的并且没有重复元素集合，它的作用是提供有序的Set集合。


·它继承于AbstractSet抽象类。


·实现了NavigableSet接口，意味着它支持一系列的导航方法。比如查找与指定目标最匹配项。


·TreeSet底层使用的是TreeMap，TreeMap的底层实现是红黑树。


·TreeSet是非线程安全的。


·TreeSet可以按照任何顺序将元素插入该集合，当对该集合进行迭代时，各个值将自动以排序后的顺序出现。


·如果想插入自定义的对象，必须通过实现Comparable接口来定义一个排列的顺序。


·TreeSet中的元素支持2种排序方式：自然排序或者根据创建TreeSet时提供的Comparator进行排序。这取决于使用的构造方法。


·TreeSet不支持快速随机遍历，只能通过迭代器进行遍历！


LinkedHashSet：


---------------------------------------


List接口：


·List接口是Collection的子接口，用于定义线性表结构，其中ArrayList可以理解为一个动态数组，而LinkedList可以理解为一个链表。


·元素是有序的(怎么存的就怎么取出来，顺序不会乱），元素可以重复因为该集合体系有索引。


· |-- ArrayList：底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）（特点是查询很快，但增删较慢）线程不同步


 |-- LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）


 |-- Vector：底层是数组数据结构 线程同步（数组长度是可变的百分之百延长）（无论查询还是增删都很慢，被ArrayList替代了）


ArrayList：

·ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(Listl）函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。


·ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。


·此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

· ArrayList构造函数，默认容量是10。


· 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(始容量x3)/2 + 1”  


LinkList：

·LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。

·LinkedList 实现 List 接口，能对它进行队列操作。

·LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。

·LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。

·LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。

·LinkedList 是非同步的。


·LinkedList是线程不安全的，可以调用Collections.synchronizedList(new LinkedList<>());实现。


Vector：


·Vector 类提供了实现可增长数组的功能，随着更多元素加入其中，数组变的更大。在删除一些元素之后，数组变小。 .


·支持线程的同步。


·Vector是默认扩展1倍。


---------------------------------------


Map接口：

HashMap


最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。


TreeMap


能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。


Hashtable


与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。 


LinkedHashMap


保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。 


ConcurrentHashMap


JDK1.5后出现，线程安全。


1).HashTable,底层是哈希表数据结构，不可以存入null键和null值，线程同步，JDK1.0效率低；
    2).HashMap,底层是哈希表数据结构，可以存入null键和null值，不同步，JDK1.2效率高；
    3).TreeMap,底层是二叉树数据结构，线程不同步，可以用于Map键排序.


  ---------------------------------------