java的集合框架不得不说

 

纯个人整理，如有错误请指正。

java的集合框架最全详解（图）

前言：数据结构对程序设计有着深远的影响，在面向过程的C语言中，数据库结构用struct来描述，而在面向对象的编程中，数据结构是用类来描述的，并且包含有对该数据结构操作的方法。

在Java语言中，Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（具体实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为Java集合框架（JavaCollectionFramework）。

Java程序员在具体应用时，不必考虑数据结构和算法实现细节，只需要用这些类创建出来一些对象，然后直接应用就可以了，这样就大大提高了编程效率。

1. 先说Set和List:

1.1. Set子接口:无序，不允许重复。List子接口:有序，可以有重复元素。具体区别是

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。<对应类有 HashSet,TreeSet>

List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。<相应类有 ArrayList,LinkedList，Vector>

Set和List具体子类：

2.2. <实例比较>

HashSet：以哈希表的形式存放元素，插入删除速度很快。

ArrayList：动态数组，LinkedList：链表、队列、堆栈。

Vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用

1.Collection接口

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。JavaSDK不提供直接继承自Collection的类，JavaSDK提供的类都是继承自Collection的“子接口”如List和Set。

所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

Iteratorit=collection.iterator();//获得一个迭代子

while(it.hasNext()){

Objectobj=it.next();//得到下一个元素

}

由Collection接口派生的两个接口是List和Set。

2.List接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

2.1.LinkedList类

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

Listlist=Collections.synchronizedList(newLinkedList(...));

2.2.ArrayList类

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率（自动增判断长度后增长也会浪费时间的呀！）。

和LinkedList一样，ArrayList也是非同步的（unsynchronized）。（扩展阅读：在java.util.concurrent包中定义的CopyOnWriteArrayList提供了线程安全的Arraylist，但是当进行add和set等变化操作时它是通过为底层数组创建新的副本实现的，所以比较耗费资源

（源码在此：publicboolean add(E e) {

finalReentrantLock lock =this.lock;

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

Object[] newElements = Arrays.copyOf(elements,len + 1);

newElements[len] = e;

setArray(newElements);

return true;

} finally {

lock.unlock();

}

}），

但是如果存在频繁遍历，遍历操作比变化（写入和修改）操作多的时候这种遍历就相对于自己进行的同步遍历效果要好，而且它也允许存在null元素）

2.3.Vector类

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。通过使用capacity和ensurecapacity操作以及capacityIncrement域可以优化存储操作，这个前面讲过，（Vector的Iterator和listIterator方法翻译的迭代器支持fail-fast机制，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。官方对此的说明是 java.util 包中的集合类都返回 fail-fast迭代器，这意味着它们假设线程在集合内容中进行迭代时，集合不会更改它的内容。如果 fail-fast迭代器检测到在迭代过程中进行了更改操作，那么它会抛出 ConcurrentModificationException，这是不可控异常。）

2.4.Stack类

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

stack 有几个比较实用的方法

boolean	empty()  测试堆栈是否为空。
E	peek()  查看堆栈顶部的对象，但不从堆栈中移除它。
E	pop()  移除堆栈顶部的对象，并作为此函数的值返回该对象。
E	push(Eitem) 把项压入堆栈顶部。
int	search(Objecto) 返回对象在堆栈中的位置，以 1 为基数。

3. set接口：

Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection,只是行为不同。(这是继承与多态思想的典型应用：表现不同的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责)
Set : 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。（我变换黄色背景那里的名称得到如下特点）

HashSet : 它不允许出现重复元素；不保证和政集合中元素的顺序，可以自己做个例子可以看出加入的字段顺序跟遍历出的不一样，允许包含值为null的元素，但最多只能有一个null元素（不允许重复嘛！）。

TreeSet : 可以实现排序等功能的集合，它在讲对象元素添加到集合中时会自动按照某种比较规则将其插入到有序的对象序列中，并保证该集合元素组成按照“升序”排列。

a)（在对大量信息进行检索的时候，TreeSet比AraayList更有效率，能保证在log(n)的时间内完成）。

b)TreeSet是实用树形结构来存储信息的，每个节点都会保存一下指针对象，分别指向父节点，左分支，右分支，相比较而言，ArrayList就是一个含有元素的简单数组了，正因为如此，它占的内存也要比ArrayList多一些。

c)想TreeSet插入元素也比ArrayList要快一些，因为当元素插入到ArrayList的任意位置时，平均每次要移动一半的列表，需要O(n)的时间， 而TreeSet深度遍历查询花费的实施只需要O(log(n))（普遍的都是，set查询慢，插入快，list查询快，插入满, .TODO:这一点我会写一个算法测试文章具体分析一下…）

LinkedHashSet : 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

PS:set有几个比较好的方法:

removeAll(Collection<?> c)

移除 set 中那些包含在指定 collection 中的元素（可选操作）。

boolean retainAll(Collection<?> c)

仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。

containsAll(Collection<?> c)

如果此 set 包含指定 collection 的所有元素，则返回 true。

4.Queue数据结构

这方面知识涉及到线程比较多，有线程基础的口语参考这篇文章

http://blog.csdn.net/a512592151/article/details/38454745

5.Map的功能方法

java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap

Map主要用于存储健值对，根据键得到值，因此不允许键重复,但允许值重复。

Hashmap 是一个 最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力.

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

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历 的时候会比HashMap慢。

TreeMap能够把它保存的记录根据键排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。

package com.hxw.T2;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;



public class MapTester {

	public static void init(Map map) {
		if (map != null) {
			String key = null;
			for (int i = 5; i > 0; i--) {
				key = new Integer(i).toString() + ".0";
				map.put(key, key.toString());
				// Map中的键是不重复的，如果插入两个键值一样的记录，
				// 那么后插入的记录会覆盖先插入的记录
				map.put(key, key.toString() + "0");
			}
		}
	}

	public static void output(Map map) {
		if (map != null) {
			Object key = null;
			Object value = null;
			// 使用迭代器遍历Map的键，根据键取值
			Iterator it = map.keySet().iterator();
			while (it.hasNext()) {
				key = it.next();
				value = map.get(key);
				System.out.println("key: " + key + "; value: " + value);
			}
			// 或者使用迭代器遍历Map的记录Map.Entry
			Map.Entry entry = null;
			it = map.entrySet().iterator();
			while (it.hasNext()) {
				// 一个Map.Entry代表一条记录
				entry = (Map.Entry) it.next();
				// 通过entry可以获得记录的键和值
				// System.out.println("key: " + entry.getKey() + "; value: " +
				// entry.getValue());
			}
		}
	}

	public static boolean containsKey(Map map, Object key) {
		if (map != null) {
			return map.containsKey(key);
		}
		return false;
	}

	public static boolean containsValue(Map map, Object value) {
		if (map != null) {
			return map.containsValue(value);
		}
		return false;
	}

	public static void testHashMap() {
		Map myMap = new HashMap();
		init(myMap);
		// HashMap的键可以为null
		myMap.put(null, "ddd");
		// HashMap的值可以为null
		myMap.put("aaa", null);
		output(myMap);
	}

	public static void testHashtable() {
		Map myMap = new Hashtable();
		init(myMap);
		// Hashtable的键不能为null
		// myMap.put(null,"ddd");
		// Hashtable的值不能为null
		// myMap.put("aaa", null);
		output(myMap);
	}

	public static void testLinkedHashMap() {
		Map myMap = new LinkedHashMap();
		init(myMap);
		// LinkedHashMap的键可以为null
		myMap.put(null, "ddd");
		// LinkedHashMap的值可以为null
		myMap.put("aaa", null);
		output(myMap);
	}

	public static void testTreeMap() {
		Map myMap = new TreeMap();
		init(myMap);
		// TreeMap的键不能为null
		// myMap.put(null,"ddd");
		// TreeMap的值不能为null
		// myMap.put("aaa", null);
		output(myMap);
	}

	public static void main(String[] args) {
		System.out.println("采用HashMap");
		MapTester.testHashMap();
		System.out.println("采用Hashtable");
		MapTester.testHashtable();
		System.out.println("采用LinkedHashMap");
		MapTester.testLinkedHashMap();
		System.out.println("采用TreeMap");
		MapTester.testTreeMap();

		Map myMap = new HashMap();
		MapTester.init(myMap);
		System.out.println("新初始化一个Map: myMap");
		MapTester.output(myMap);
		// 清空Map
		myMap.clear();
		System.out.println("将myMap clear后，myMap空了么?  " + myMap.isEmpty());
		MapTester.output(myMap);
		myMap.put("aaa", "aaaa");
		myMap.put("bbb", "bbbb");
		// 判断Map是否包含某键或者某值
		System.out.println("myMap包含键aaa?  "
				+ MapTester.containsKey(myMap, "aaa"));
		System.out.println("myMap包含值aaaa?  "
				+ MapTester.containsValue(myMap, "aaaa"));
		// 根据键删除Map中的记录
		myMap.remove("aaa");
		System.out.println("删除键aaa后，myMap包含键aaa?  "
				+ MapTester.containsKey(myMap, "aaa"));
		// 获取Map的记录数
		System.out.println("myMap包含的记录数:  " + myMap.size());
	}
}

附：map 遍历的四种方法：

public static void main(String[] args) {


  Map<String, String> map = new HashMap<String, String>();
  map.put("1", "value1");
  map.put("2", "value2");
  map.put("3", "value3");
  
  //第一种：普遍使用，二次取值
  System.out.println("通过Map.keySet遍历key和value：");
  for (String key : map.keySet()) {
   System.out.println("key= "+ key + " and value= " + map.get(key));
  }
  
  //第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value：");
  Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry<String, String> entry = it.next();
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }
  
  //第三种：推荐，尤其是容量大时
  System.out.println("通过Map.entrySet遍历key和value");
  for (Map.Entry<String, String> entry : map.entrySet()) {
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第四种
  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
  for (String v : map.values()) {
   System.out.println("value= " + v);
  }
 }

3、其他特征

*List，Set，Map将持有对象一律视为Object型别。

*Collection、List、Set、Map都是接口，不能实例化。

继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。

*vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。

三、Collections

Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各种集合的搜索、排序、线程完全化等操作。

相当于对Array进行类似操作的类——Arrays。

如，Collections.max(Collection coll); 取coll中最大的元素。

Collections.sort(List list); 对list中元素排序

四、如何选择？

1、容器类和Array的区别、择取

* 容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。

* 一旦将对象置入容器内，便损失了该对象的型别信息。

2、

* 在各种Lists中，最好的做法是以ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList()；

Vector总是比ArrayList慢，所以要尽量避免使用。

* 在各种Sets中，HashSet通常优于TreeSet（插入、查找）。只有当需要产生一个经过排序的序列，才用TreeSet。

TreeSet存在的唯一理由：能够维护其内元素的排序状态。

* 在各种Maps中

HashMap用于快速查找。

* 当元素个数固定，用Array，因为Array效率是最高的。

结论：最常用的是ArrayList，HashSet，HashMap，Array。而且，我们也会发现一个规律，用TreeXXX都是排序的。

注意：

1、Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。

2、Set和Collection拥有一模一样的接口。

3、List，可以通过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)

4、一般使用ArrayList。用LinkedList构造堆栈stack、队列queue。

5、Map用 put(k,v) / get(k)，还可以使用containsKey()/containsValue()来检查其中是否含有某个key/value。

HashMap会利用对象的hashCode来快速找到key。

* hashing

哈希码就是将对象的信息经过一些转变形成一个独一无二的int值，这个值存储在一个array中。

我们都知道所有存储结构中，array查找速度是最快的。所以，可以加速查找。

发生碰撞时，让array指向多个values。即，数组每个位置上又生成一个梿表。

6、Map中元素，可以将key序列、value序列单独抽取出来。

使用keySet()抽取key序列，将map中的所有keys生成一个Set。

使用values()抽取value序列，将map中的所有values生成一个Collection。

为什么一个生成Set，一个生成Collection？那是因为，key总是独一无二的，value允许重复。

 

原文链接:http://DavidIsOK.iteye.com/blog/2106563

 

 

 

Java中Vector和ArrayList的区别

 

      首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：

1. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
2. Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
3. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

     查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。

ArrayList中：

1 public boolean add(E e) {
2 
3 ensureCapacity(size + 1); // 增加元素，判断是否能够容纳。不能的话就要新建数组
4  
5 elementData[size++] = e;
6 
7 return true;
8 
9 }
10 
11  public void ensureCapacity(int minCapacity) {
12 
13 modCount++; 
14 
15 int oldCapacity = elementData.length;
16 
17 if (minCapacity > oldCapacity) {
18 
19 Object oldData[] = elementData; // 此行没看出来用处，不知道开发者出于什么考虑
20  
21 int newCapacity = (oldCapacity * 3)/2 + 1; // 增加新的数组的大小
22  
23 if (newCapacity < minCapacity)
24 
25 newCapacity = minCapacity;
26 
27 // minCapacity is usually close to size, so this is a win:
28  
29 elementData = Arrays.copyOf(elementData, newCapacity);
30 
31 }
32 
33 }
34 
35  

Vector中：

1 private void ensureCapacityHelper(int minCapacity) {
2 
3 int oldCapacity = elementData.length;
4 
5 if (minCapacity > oldCapacity) {
6 
7 Object[] oldData = elementData;
8 
9 int newCapacity = (capacityIncrement > 0) ?
10 
11 (oldCapacity + capacityIncrement) : (oldCapacity * 2);
12 
13 if (newCapacity < minCapacity) {
14 
15 newCapacity = minCapacity;
16 
17 }
18 
19 elementData = Arrays.copyOf(elementData, newCapacity);
20 
21 }
22 
23 }
24 
25

关于ArrayList和Vector区别如下：

1. ArrayList在内存不够时默认是扩展50% + 1个，Vector是默认扩展1倍。
2. Vector提供indexOf(obj, start)接口，ArrayList没有。
3. Vector属于线程安全级别的，但是大多数情况下不使用Vector，因为线程安全需要更大的系统开销。

 

 总结：

 

1）java集合框架的层次结构

 

2）使用Collection接口定义的公用方法对集合和线性表操作

 

3）使用Iterator接口遍历集合

 

4）使用JDK的增强for循环替代迭代Iterator进行集合遍历

 

5）熟悉Set接口，了解何时及如何使用HashSet，LinkedHashSet或TreeHashSet来存储元素

 

6）使用Comparator接口来比较元素

7）熟悉List接口，了解何时以及如何使用ArrayList或者LinkedList来存储元素
8）区分Vector与ArrayList，并了解如何使用Vector和Stack

9）使用JDK1.5的一般类型来简化程序设计

10）理解Collection和Map的区别，知道何时及如何使用HashMap，LinkedHashMap，TreeHashMap来存储

11）使用Collections类中的静态方法
12）使用Arrays类中的静态方法


以上就是java集合框架的内容，如果你对哪一条不熟悉，说明需要好好的看看。

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

java集合架构支持3种类型的集合：规则集（Set），线性表（List），和图（Map），分别定义在Set，List，Map中。Set实例存储一组互不相同的元素（集合），List实例存储一组顺序排列的元素（表），Map存储一组 对象---关键值的映射


总的架构如下，非常重要，包含继承关系，实现的分类，一目了然：

Collection接口：　

 

　　　　　　　Set接口：

 

　　　　　　　　　　　　HashSet具体类

　　　　　　　　　　　　LinkedHashSet具体类

　　　　　　　　　　　　TreeSet具体类

　　　　　　　List接口：　
　　　　　　　　　　　　ArrayList具体类

　　　　　　　　　　　　LinkedList具体类

　　　　　　　　　　　　向量类Vector具体类

　　　　　　　　　　　　Stack具体类


Map接口：
　　　　　　　HashMap类

　　　　　　　LinkedHashMap类

　　　　　　　TreeMap类　　　　　　　　　　　　
　　　　
---------------------------------------------------------------------------------------------------------------------------------------------------

 

1）先来说Collection接口，它是处理对象集合的根接口，提供了一些公用方法，size，Iterator，add，remove什么的

2）Set和List接口都扩展自Collection，Set就是高中数学里所说的集合，不允许重复，无序。List就像一个表，可以重复，元素在表里有顺序的放着。

3）然后来说Set接口的3种实现：

　　HashSet的对象必须实现hashCode方法，javaAPI大多数类实现了hashCode方法。
　　LinkedHashSet实现了对HashSet的扩展，支持规则集内元素的排序，在HashSet中元素是没有顺序的，而在LinkedHashSet中，可以按元素插入集合的顺序进行提取
　　TreeSet保证集中的元素是有序的，有2种方法可以实现对象之间的可比较性：1，添加到TreeSet的对象实现了Comparable接口；2，给规则集的元素指定一个比较器（Comparator）

使用提示：

如果希望按照元素插入集合的顺序进行提取元素，用LinkedHashSet，它的元素按添加的顺序存储

如果没有上述需求，应该用HashSet，它的效率比LinkedHashSet高

LinkedHashSet只是按照添加的的先后顺序在存储时保持顺序，要给集合元素添加顺序属性，需要使用TreeSet（集合元素有排序关系）。


4）再来说List的几种实现

最重要的的当然是ArrayList（不同步）和LinkedList，一个使用数组实现的动态扩展容量的list，一个是链式实现的list。

还有就是Vector（同步）类，它除了包含访问和修改向量的同步方法之外，跟ArrayList一样。

最后就是Stack类，它继承自Vector类，，但一般只作为栈的功能来使用，不要去使用Vector里面的功能


5）Map

Map是映射，跟前面的Set和List有本质的区别。

散列图HashMap，链式散列图LinkedHashMap，树形图TreeHashMap是映射的3种实现，从名字上来说，有了上述Set的3种实现的分析，这个也是类似的。

HashMap：效率高
LikedHashMap：按照添加顺序存储，可以按添加顺序取出
TreeHashMap：排序性

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


Collections类和Arrays类：

Collections类（注意不是Collection）：提供了许多静态的方法来管理集合，线性表（大多数是来操作线性表的，比如对线性表复制，排序之类的，参见API）

Arrays类：提供了对数组排序，查找，比较，填充元素的各种静态方法。

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

 

一般类型的使用：

是指在java集合中使用泛型来指定添加元素的类型：

HashMap<K,V>  map  =  new HashMap<K,V>()   其中K，V是两个类类型，表明这里只能填充k，v类型的对象

另外集合中只能添加对象，对于基本数据类型，会自动转型为对应的包装类。

 

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。

 

java集合框架：

 

1. 什么是框架：类库的集合

 

2.集合框架：用来表示和操作的统一的架构，包含了实现集合的接口与类

 

3.集合：存放数据的容器

 

集合框架包含了两部分：一部分是接口，一部分是类

 

4.为什么会出现接口：因为集合框架中的很多类 功能是相似的【所以用接口来规范类】

 

主要结构图：

 

 

注:在"集合框架"中，接口 Map 和 Collection 在层次结构没有任何亲缘关系，它们是截然不同的。

 

不要简单的认为集合类机会就这些，jdk中集合类有很多这些不过是我们经常用到的而已
Collection、List、Set、Queue和Map都是接口（Interface），不是具体的类实现。

 

一．List[public interface List<E>extends Collection<E>]:

 

A．有序的集合接口，可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

 

B．与 set 不同，列表通常允许重复的元素。更正式地说，列表通常允许元素e1和元素e2满足e1.equals(e2).并且如果列表本身允许null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表

 

C．List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，更加规范了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明

 

D．List 接口提供了 4 种对列表元素进行定位（索引）访问方法。列表（像 Java 数组一样）是基于 0 的。注意，这些操作可能在和某些实现（例如 LinkedList 类）的索引值成比例的时间内执行。因此，如果调用方不知道实现，那么在列表元素上迭代通常优于用索引遍历列表

 

E. 除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

 

至于 List提供如下方法：

 

 

 

 

List接口实现类很多：

 

AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector 一般情况下主要用到的是ArrayList，和LinkedList，其他的类并不是说没用 

 

ArrayList

 

ArrayList允许所有元素包括null。ArrayList没有同步

 

理解一：ArrayList 使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由 ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。

 

对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在 ArrayList分配完毕之后去掉浪费掉的空间。

 

理解二：ArrayList是用数组实现的，它不是真正的链表，在初始化的时候它先对数组设置一个初始容量，当数组空间不够的时候，它会重新构建一个容量更大的数组，然后把先前的元素拷贝进去

 

不管是一还是二暂且不管他存放元素的方式。唯一一点可以确认他使用内置的数组

 

LinkedList 

 

List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，

 

LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列 (deque)。此类实现 Queue 接口，为 add、poll 等提供先进先出队列操作。其他堆栈和双端队列操作可以根据标准列表操作方便地进行再次强制转换。虽然它们可能比等效列表操作运行稍快，但是将其包括在这里主要是出于方便考虑.