java集合（list,set,map)

集合

集合与数组

数组（能够存储基本数据类型）是用来存现对象的一种容器，可是数组的长度固定，不适合在对象数量未知的状况下使用。

集合（只能存储对象，对象类型能够不同）的长度可变，可在多数状况下使用。
注：数组我在前面的博客讲了你们能够看下

集合中接口和类的关系

Collection接口是集合类的根接口，Java中没有提供这个接口的直接的实现类。可是却让其被继承产生了两个接口，就是Set和List。Set中不能包含重复的元素。List是一个有序的集合，能够包含重复的元素，提供了按索引访问的方式。

Map是Java.util包中的另外一个接口，它和Collection接口没有关系，是相互独立的，可是都属于集合类的一部分。Map包含了key-value对。Map不能包含重复的key，可是能够包含相同的value。

Iterator全部的集合类，都实现了Iterator接口，这是一个用于遍历集合中元素的接口，主要包含如下三种方法：
1.hasNext()是否还有下一个元素。
2.next()返回下一个元素。
3.remove()删除当前元素。

层次图

图一这个比较简单

图二完整

list,set,map对比

接口	子接口	是否有序	是否容许元素重复
Collection		否
List	ArrayList	否	是
	LinkedList	否	是
	Vector	否	是
Set	AbstractSet	否	否
	HashSet	否	否
	TreeSet	是（用二叉排序树）	否
Map	AbstractMap	否	使用key-value来映射和存储数据，key必须惟一，value能够重复
	HashMap		否
	TreeMap	是（用二叉排序树）	使用key-value来映射和存储数据，key必须惟一，value能够重复

list（有序、可重复）

List里存放的对象是有序的，同时也是能够重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。由于往list集合里插入或删除数据时，会伴随着后面数据的移动，全部插入删除数据速度慢。

ArrayList

　　ArrayList是基于数组的，在初始化ArrayList时，会构建空数组（Object[] elementData={}）。ArrayList是一个无序的，它是按照添加的前后顺序排列，固然，他也提供了sort方法，若是须要对ArrayList进行排序，只须要调用这个方法，提供Comparator比较器便可

add操做：

　　1）若是是第一次添加元素，数组的长度被扩容到默认的capacity，也就是10.

　　2) 当发觉同时添加一个或者是多个元素，数组长度不够时，就扩容，这里有两种状况：

　　只添加一个元素，例如：原来数组的capacity为10，size已经为10，不能再添加了。须要扩容，新的capacity=old capacity+old capacity>>1=10+10/2=15.即新的容量为15。

　　当同时添加多个元素时，原来数组的capacity为10，size为10，当同时添加6个元素时。它须要的min capacity为16，而按照capacity=old capacity+old capacity>>1=10+10/2=15。new capacity小于min capacity，则取min capacity。

　　对于添加，若是不指定下标，就直接添加到数组后面，不涉及元素的移动，若是要添加到某个特定的位置，那须要将这个位置开始的元素日后挪一个位置，而后再对这个位置设置。

Remove操做：

　Remove提供两种，按照下标和value。

　　1）remove(int index)：首先须要检查Index是否在合理的范围内。其次再调用System.arraycopy将index以后的元素向前移动。

　　2）remove(Object o)：首先遍历数组，获取第一个相同的元素，获取该元素的下标。其次再调用System.arraycopy将index以后的元素向前移动。

Get操做：

　　这个比较简单，直接对数组进行操做便可。

LinkedList

　　LinkedList是基于链表的，它是一个双向链表，每一个节点维护了一个prev和next指针。同时对于这个链表，维护了first和last指针，first指向第一个元素，last指向最后一个元素。LinkedList是一个无序的链表，按照插入的前后顺序排序，不提供sort方法对内部元素排序。

Add元素：

　　LinkedList提供了几个添加元素的方法：addFirst、addLast、addAll、add等，时间复杂度为O(1)。

Remove元素：

　　LinkedList提供了几个移除元素的方法：removeFirst、removeLast、removeFirstOccurrence、remove等，时间复杂度为O(1)。

Get元素：

　　根据给定的下标index，判断它first节点、last直接距离，若是index<size（数组元素个数)/2,就从first开始。若是大于，就从last开始。这个和咱们日常思惟不太同样，也许按照咱们的习惯，从first开始。这也算是一点当心的优化吧。

遍历

在类集中提供了如下四种的常见输出方式：

1）Iterator：迭代输出，是使用最多的输出方式。

2）ListIterator：是Iterator的子接口，专门用于输出List中的内容。

3）foreach输出：JDK1.5以后提供的新功能，能够输出数组或集合。

4）for循环

代码示例以下：

for的形式：for（int i=0;i<arr.size();i++）{...}

foreach的形式： for（int　i：arr）{...}

iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}

Set（无序、不能重复）

Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

HashSet

　　HashSet是基于HashMap来实现的，操做很简单，更像是对HashMap作了一次“封装”，并且只使用了HashMap的key来实现各类特性，而HashMap的value始终都是PRESENT。

　　HashSet不容许重复（HashMap的key不容许重复，若是出现重复就覆盖），容许null值，非线程安全。

构造方法

HashSet()
　　构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection<? extends E> c)
　　构造一个包含指定 collection 中的元素的新 set。
HashSet(int initialCapacity)
　　构造一个新的空 set，其底层 HashMap 实例具备指定的初始容量和默认的加载因子（0.75）。
HashSet(int initialCapacity, float loadFactor)
　　构造一个新的空 set，其底层 HashMap 实例具备指定的初始容量和指定的加载因子。

方法

boolean add(E e)
　　若是此 set 中还没有包含指定元素，则添加指定元素。
void clear()
　　今后 set 中移除全部元素。
** Object clone()
　　返回此 HashSet 实例的浅表副本：并无复制这些元素自己。
boolean contains(Object o)
　　若是此 set 包含指定元素，则返回 true。
boolean isEmpty()**
　　若是此 set 不包含任何元素，则返回 true。
** Iterator iterator()
　　返回对此 set 中元素进行迭代的迭代器。
boolean remove(Object o)
　　若是指定元素存在于此 set 中，则将其移除。
int size()**
　　返回此 set 中的元素的数量（set 的容量）。

TreeSet

　　基于 TreeMap 的 NavigableSet 实现。使用元素的天然顺序对元素进行排序，或者根据建立 set 时提供的 Comparator进行排序，具体取决于使用的构造方法。

　　构造方法和方法比较相似就不说了

遍历（和list类似）

对 set 的遍历

1.迭代遍历：

Set<String> set = new HashSet<String>();  
Iterator<String> it = set.iterator();  
while (it.hasNext()) {  
  String str = it.next();  
  System.out.println(str);  
}

2.for(foreach)循环遍历：

for (String str : set) {  
      System.out.println(str);  
}

Map（键值对、键惟1、值不惟一）

　　Map集合中存储的是键值对，键不能重复，值能够重复。根据键获得值，对map集合遍历时先获得键的set集合，对set集合进行遍历，获得相应的值。

HashMap

　　数组方式存储key/value，线程非安全，容许null做为key和value，key不能够重复，value容许重复，不保证元素迭代顺序是按照插入时的顺序，key的hash值是先计算key的hashcode值，而后再进行计算，每次容量扩容会从新计算因此key的hash值，会消耗资源，要求key必须重写equals和hashcode方法

　　默认初始容量16，加载因子0.75，扩容为旧容量乘2，查找元素快，若是key同样则比较value，若是value不同，则按照链表结构存储value，就是一个key后面有多个value；

方法

一、添加：

　　V put(K key, V value) （能够相同的key值，可是添加的value值会覆盖前面的，返回值是前一个，若是没有就返回null）

　　putAll(Map<? extends K,? extends V> m) 从指定映射中将全部映射关系复制到此映射中（可选操做）。

二、删除

　　remove() 删除关联对象，指定key对象

　　clear() 清空集合对象

三、获取

　　value get(key) 能够用于判断键是否存在的状况。当指定的键不存在的时候，返回的是null。

４、判断：

　　boolean isEmpty() 长度为0返回true不然false

　　boolean containsKey(Object key) 判断集合中是否包含指定的key

　　boolean containsValue(Object value) 判断集合中是否包含指定的value

四、长度：

　Int size（）

　　map的主要的方法就这几个

Hashtable

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

LinkedHashMap

LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先获得的记录确定是先插入的，在遍历的时候会比HashMap慢，有HashMap的所有特性。

TreeMap

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

遍历

第一种：KeySet()
　　将Map中全部的键存入到set集合中。由于set具有迭代器。全部能够迭代方式取出全部的键，再根据get方法。获取每个键对应的值。 keySet():迭代后只能经过get()取key 。
　　取到的结果会乱序，是由于取得数据行主键的时候，使用了HashMap.keySet()方法，而这个方法返回的Set结果，里面的数据是乱序排放的。

Map map = new HashMap();
    map.put("key1","lisi1");
    map.put("key2","lisi2");
    map.put("key3","lisi3");
    map.put("key4","lisi4");  
    //先获取map集合的全部键的set集合，keyset（）
    Iterator it = map.keySet().iterator();
    //获取迭代器
    while(it.hasNext()){
        Object key = it.next();
        System.out.println(map.get(key));
    }

第二种： values() 获取全部的值.
Collection values() 不能获取到key对象

Collection<String> vs = map.values();
        Iterator<String> it = vs.iterator();
        while (it.hasNext()) {
            String value = it.next();
            System.out.println(" value=" + value);
        }

第三种：entrySet（）
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。（一个关系就是一个键-值对），就是把(key-value)做为一个总体一对一对地存放到Set集合当中的。Map.Entry表示映射关系。entrySet()：迭代后能够e.getKey()，e.getValue()两种方法来取key和value。返回的是Entry接口。
典型用法以下：

// 返回的Map.Entry对象的Set集合 Map.Entry包含了key和value对象
        Set<Map.Entry<Integer, String>> es = map.entrySet();

        Iterator<Map.Entry<Integer, String>> it = es.iterator();

        while (it.hasNext()) {
            
            // 返回的是封装了key和value对象的Map.Entry对象
            Map.Entry<Integer, String> en = it.next();

            // 获取Map.Entry对象中封装的key和value对象
            Integer key = en.getKey();
            String value = en.getValue();

            System.out.println("key=" + key + " value=" + value);
        }

　　推荐使用第三种方式，即entrySet()方法，效率较高。
　　对于keySet实际上是遍历了2次，一次是转为iterator，一次就是从HashMap中取出key所对于的value。而entryset只是遍历了第一次，它把key和value都放到了entry中，因此快了。两种遍历的遍历时间相差仍是很明显的。

总结：

Vector和ArrayList

　　1，vector是线程同步的，因此它也是线程安全的，而arraylist是线程异步的，是不安全的。若是不考虑到线程的安全因素，通常用arraylist效率比较高。

　　2，若是集合中的元素的数目大于目前集合数组的长度时，vector增加率为目前数组长度的100%，而arraylist增加率为目前数组长度的50%。若是在集合中使用数据量比较大的数据，用vector有必定的优点。

　　3，若是查找一个指定位置的数据，vector和arraylist使用的时间是相同的，若是频繁的访问数据，这个时候使用vector和arraylist均可以。而若是移动一个指定位置会致使后面的元素都发生移动，这个时候就应该考虑到使用linklist,由于它移动一个指定位置的数据时其它元素不移动。

　　ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增长和插入元素，都容许直接序号索引元素，可是插入数据要涉及到数组元素移动等内存操做，因此索引数据快，插入数据慢，Vector因为使用了synchronized方法（线程安全）因此性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据须要进行向前或向后遍历，可是插入数据时只须要记录本项的先后项便可，因此插入数度较快。

arraylist和linkedlist

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

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

　　3.对于新增和删除操做add和remove，LinedList比较占优点，由于ArrayList要移动数据。 这一点要看实际状况的。若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但如果批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 由于ArrayList每插入一条数据，要移动插入点及以后的全部数据。

HashMap与TreeMap

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

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

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

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

HashTable与HashMap

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

　　二、HashMap容许存在一个为null的key，多个为null的value 。

　　三、hashtable的key和value都不容许为null。