Java集合类架构层次关系
集合指多个元素的聚集体。
Java中的集合类主要是由两个接口派生而出：
1):Collection接口: 存储一组对象,一次存一个元素, 是单列集合
Collection体系包括Set(无序集合，元素不可重复)，List(有序集合，元素可以重复)，Queue(队列集合)
Collection是java.util下的集合接口，是集合类的上级接口。
Collection提供了对集合对象进行基本操作的通用接口方法，它在Java类库中有很多具体的实现，
Collection的意义在于为各种具体的集合提供最大化的统一操作方式。
Collections是一个包装类，有关于集合操作的一系列静态方法，实现对各类集合的搜索，排序，线程安全化等操作。
2):Map接口:保存具有映射关系的数据,存储一些关键字/值对,是双列集合
Map体系包括map(保存具有映射关系的数据)
常见的集合类：
1.List结构的集合类
ArrayList类，LinkedList类，Vector类,Stack类
2.Map结构的集合类
HashMap类，HashTable类
3.Set结构的集合类
HashSet类，Tree类
4.Queue结构的集合类
Queue接口
1.对List集合遍历
1.Iterator
2.ListIterator
3.for+get+size
4.增强for
2.对Set集合遍历
1.Iterator
2.增强for
集合和数组的区别：
1：数组是固定长度的；集合可变长度的,可以动态增长的数据
2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
数组转集合：asList()方法
String[] arr ={"123","456","789"};
List<String> list = Arrays.asList(arr);
集合转数组：toArray()方法
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String[] arr = al.toArray(new String[al.size()]),
Collection 和 Collections的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
collection是集合的根接口。
java.util.Collections是类。此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
集合框架中容器简单用法：
①List 集合元素是有序，不唯一：
ArrayList 低层是数组，替代了 Vector，查询速度快；
LinkedList 低层是链表，，增删速度快；
Vector 低层也是数组，速度很慢，已经过时；
②Set 集合元素是无序，唯一；
HashSet 低层是哈希表；
LinkedHashSet 是 HashSet 的子类
TreeSet 底层是二叉树,
③Map 集合（键值对）
HashTable 低层是哈希表，不存在 null 键和 null 值；
HashMap 低层是哈希表，存在 null 键和 null 值；
TreeMap 低层是二叉树
技巧：Array 是数组结构，有角标，查询速度很快。link 就是链表结构：增删速度快，而且有特有方法，addFirst 、 addLast、removeFirst()、removeLast()、getFirst()、getLast()。
hash 就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖 hashCode ，equals方法 tree 就是二叉树，就要想到排序，就想要用到比较。
ArrayList类:
定义： ArrayList arr = new ArrayList();
添加数据： arr.add(数据)
删除数据：arr.remove(数据)
取出数据
数据的类型 数据名 = （数据类型） arr.get（下标）
注意：没有使用泛型时，取出的数据需要强制转换。
2.List和Set的相同点在于它们都继承Collection,它们的不同点在于,List是一种有序的Collection，
* 可以按照索引来访问List中的元素，Set是一种不包含重复元素的Collection，只能有一个NULL元素.
*
* 3.Map有三种常用类，分别是HashMap，HashTable，TreeMap.
* HashMap的特点是，效率高，允许空值，线程不同步
* HashTable的特点是，效率低，不允许空值，线程同步
* TreeMap的特点是，所有元素保持一个固定的顺序，可用于Map集合中元素排序，不允许键对象是null
操作集合的工具类：Collections：（注意不是Collection）
1):Collections 是一个操作 Set、List 和 Map 等集合的工具类
2):Collections 中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
排序操作：
—reverse(List)：反转 List 中元素的顺序。
—shuffle(List)：对 List 集合元素进行随机排序。
—sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序。
—sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
—swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换。
同步控制：
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，
从而可以解决多线程并发访问集合时的线程安全问题。
-- synchronizedCollection(Collection<T> c)
-- synchronizedList(List<T> c)
-- synchronizedMap(Map<T> c)
-- synchronizedSet(Set<T> c)
-- synchronizedSortedMap(SortedMap<T> c)
-- synchronizedSortedSet(SortedSet<T> c)
1. Interface Iterable 迭代器接口，
这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。
这个Iterable接口只有一个方法: iterator()。它返回一个代表当前集合对象的泛型<T>迭代器，用于之后的遍历操作
1.1 Collection
Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。
Collection是一个接口，用以提供规范定义，不能被实例化使用
1) Set
Set集合类似于一个罐子，"丢进"Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。
Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，在加入一个新元素的时，如果这个新元素对象和Set中已有对象进行equals比较返回false，则Set就会接受这个新元素对象，否则拒绝。
因为Set的这个制约，在使用Set集合的时候，应该注意两点：
1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法、
2) 对Set的构造函数，传入的Collection参数不能包含重复的元素
1.1) HashSet
HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。
当向HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。
值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等
1.1.1) LinkedHashSet
LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。
当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)
1.2) SortedSet
此接口主要用于排序操作，即实现此接口的子类都属于排序的子类
1.2.1) TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
1.3) EnumSet
EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，
它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序
2) List
List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素
的添加顺序设置元素的索引
2.1) ArrayList
ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。
2.2) Vector
Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将
Vector改为实现List接口，统一归入集合框架体系中
2.2.1) Stack
Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出)
2.3) LinkedList
implements List<E>, Deque<E>。实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列
使用。自然也可以被当作"栈来使用"
3) Queue
Queue用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，
访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念
3.1) PriorityQueue
PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以
看出来
3.2) Deque
Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用
3.2.1) ArrayDeque
是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重
新分配一个Object[]数组来存储集合元素
3.2.2) LinkedList
1.2 Map
Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允
许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。
关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合
Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)
Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
1) HashMap
和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、
同时两个key的hashCode值也必须相等
1.1) LinkedHashMap
LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区
分)
2) Hashtable: 是一个古老的Map实现类
2.1) Properties
Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文
件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中
3) SortedMap
正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类
3.1) TreeMap
TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的
key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序
4) WeakHashMap
WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。
但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃
圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对
5) IdentityHashMap
IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等
6) EnumMap
EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序
(即枚举值在枚举类中的定义顺序)
Collections API的体系结构
集合是代表一组对象的单个对象。集合中的对象叫元素。集合用于处理多种类型对象的问题，所有的类型都有一个特殊的种类(也就是说，它们都是从一个共同父类继承来的)。
集合可用于保存，处理Object类型的对象。这允许在收集中贮存任何对象，还可以在使用对象前从集合中检索到它之后，使用正确的类型转换为我们所需要的对象类型。
在程序设计中经常会用到各种各样的数据结构，如：表、映射、清单、树、集合等。显然，这些数据结构都满足集合的定义。为了方便处理各种各样的数据结构，Java在Java.util包中提供了一组API。这组API中的大部分类都实现了Collection接口，因此，被称作Collections API。
API还包括诸如HashSet, ArraySet, ArrayList, LinkedList和Vector等等的类，它们实现这些接口。API还提供了支持某些算法的方法，如：排序，二进制搜索，计算列表中的最小和最大等。
List，Set,Map将所有的对象一律视为Object类型
Collection，List，Set，Map都是接口，不能实例化。继承自他们的ArrayList，HashTable,HashMap等是具体类，这些才能被实例化
关于Clooections，值针对集合类的一个帮助类，提供一系列静态方法来实现对集合的搜索，排序，线程安全化等操作，相当于array进行类似操作的类Arrays
如何选择容器:
• 在各种List中，最好的是以ArrayList作为默认选择，当插入，删除频繁时，使用LinkedList().
• 在各种Set中，HashSet通常由于HashTree(插入，查找)，只是当需要排序是，才用TreeSet
• 在各种Map中，HashMap用于快速查找
• 当元素固定时，最好使用Array，因为Array的效率是最高的。
Collection：表示一组各自独立的元素，通常拥有相同的套用规则。接口类：java.util.Collection
List和Set就由它派生，套用规则分别为：List必须以特定次序来持有各元素，而Set无法拥有重复的元素。
Collection接口中所定义的方法：
-- int size()
-- boolean isEmpty()
-- void clear()
-- boolean contains(Object ele)
-- boolean add(Object ele)
-- boolean remove(Object ele)
-- Iterator iterator()
-- boolean containsAll(Collection c)
-- boolean addAll(Collection c)
-- boolean removeAll(Collection c)
-- boolean retainAll(Collection c) 求交集
-- Object[] toArray()
集合根据它们处理的不同种类的数据结构，Collections API可分为三类：
(Collection)收集---没有具体顺序的一组对象
(Set)设定---没有重复的一组对象，(无序集合，元素不可重复)
(List)列表---有序对象组，允许重复(有序集合，元素可以重复)
集合框架中容器简单用法：
1):List 集合元素是有序，可重复，不唯一，每个元素都有其对应的顺序索引：默认按元素的添加顺序设置元素的索引
List 集合里添加了一些根据索引来操作集合元素的方法：
-- void add(int index, Object ele)
-- boolean addAll(int index, Collection eles)
-- Object get(int index)
-- int indexOf(Object obj)
-- int lastIndexOf(Object obj)
-- Object remove(int index)
-- Object set(int index, Object ele)
-- List subList(int fromIndex, int toIndex)
额外方法: listIterator()该方法返回一个 ListIterator 对象
1.1):ArrayList 底层是数组，替代了 Vector，查询速度快；
擅长随机访问元素，但在List中间插入，删除，移动元素较慢
定义： ArrayList arr = new ArrayList();
添加数据：arr.add(数据)
删除数据：arr.remove(数据)
取出数据：数据的类型 数据名 = （数据类型） arr.get（下标） 注意：没有使用泛型时，取出的数据需要强制转换。
1.2):LinkedList 底层是链表，增删速度快；
插入，删除，移动元素方便，随机访问元素差
特有方法: addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
1.3):Vector 底层也是数组，速度很慢，已经过时,不推荐使用，建议使用 ArrayList，虽然其线程安全。
2):Set 集合元素是无序，哈希值,唯一，加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。要覆盖 hashCode ，equals方法
2.1):HashSet 底层是哈希表；为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。
2.2):LinkedHashSet 是 HashSet 的子类, 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
2.3):TreeSet 底层是二叉树, 保存次序的Set,使用它可以从Set中提取有序的序列。
3):Map集合:
map存储了一系列键值的映射关系，
map集合需要保证键值的唯一性
可以通过键值获得值，反之则不能
map集合存储元素使用put（key，value）方法
map集合的两种遍历方式
通过keySet方法返回由键组成的集合，迭代该集合的元素就拿到了所有的键，再调用get方法根据键拿到值
通过entrySet方法返回键值映射关系组成的集合，迭代该集合就拿到了一个个的聚氨酯映射关系，通过getKey方法拿到键
Map 集合（键值对）, 接口类：java.util.Map
用于保存具有映射关系的数据,key 和 value 都可以是任何引用类型的数据
严格的实现类只有HashMap和TreeMap，但另外还有两个也实现了该接口，即LinkedHashMap和HashTable。
null值可以作为键，但只能有一个，而可以有一个或多个键对应的value值为null，因此在HashMap中不能用get()方法来判断其是否存在某个key，应该用contains
执行效率是Map的一个大问题。看看get()要做哪些事，就会明白为什么在ArrayList中搜索“键”是相当慢的。而这正是HashMap提高速度的地方。HashMap使用了特殊的值，称为“散列码”(hash code)，来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值，它是通过将该对象的某些信息进行转换而生成的。所有Java对象都能产生散列码，因为hashCode()是定义在基类Object中的方法。
Map 中的Key 不允许重复（值可以）,同一个 Map 对象的任何两个 Key 通过 equals 方法比较
Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value
3.1):HashTable 底层是哈希表，古老的 Map 实现类，线程安全,但不建议使用,不存在 null 键和 null 值；
线程安全，速度慢，不允许存放null值，已被HashMap取代。
3.2):HashMap 底层是哈希表，存在 null 键和 null 值；
线程不安全，存取速度快，允许存放null值。通过HashSet原理保证键的唯一性。
使用对象的hashCode()进行快速查询的。此方法能够显著提高性能。
在缺省情况下是非同步的，其同步问题可以通过Collections的静态方法来解决，如Map Collections.synchronizedMap(Map m)；
Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。
3.3):Properties：是HashSet的子类，所以他的线程也是安全的。
它用于读写配置文件，一般配置项等号两边都是String，所以该集合的两列保存的都是String类型的数据，这个集合只能存String，所以不需要定义泛型。
3.4):TreeMap 底层是二叉树,存储 Key-Value 对时，需要根据 Key 对 key-value 对进行排序
通过二叉树算法保证键的唯一性，它对键进行排序，排序原理与TreeSet原理相同。
TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
TreeMap 可以保证所有的 Key-Value 对处于有序状态
TreeMap 的 Key 的排序：
——自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException。
——定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口。
3.5):WeakHashMao : 弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。
3.6):IdentifyHashMap : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。
注意：
1):与HashSet 集合不能保证元素的顺序的顺序一样，Hashtable 、HashMap 也不能保证其中key-value 对的顺序;
2):Hashtable 、HashMap 判断两个 Key 相等的标准是：两个 Key 通过 equals 方法返回 true，hashCode 值也相等;
3):Hashtable 、HashMap 判断两个 Value相等的标准是：两个 Value 通过 equals 方法返回 true;
4):LinkedHashMap 是 HashMap 的子类,可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致;
Map常用方法：
-- void clear()
-- boolean containsKey(Object key)
-- boolean containsValue(Object value)
-- Set<Map,Entry<E,Y>> entrySet()
-- boolean equals(Object o)
-- V get(Object key)
-- int hashCode()
-- boolean isEmpty()
-- keySet()
-- put(key,value)
-- putAll()
-- remove()
-- int size()
-- values()
五，HashMap和HashTable的区别
相同点：都继承了Map接口的类
不同点：
HashMap类没有分类或者排序，她允许一个null键和多个null值
HashTable和HashMap一样，但是不允许null键和null值，他比hashMap慢，因为它是同步的
hashTable的是contains方法，而hashmap的是containskey和containsvalue方法
Iterator接口也是Java集合框架的成员，但它与Collection,Map体系不同，不是用于装载其它对象，而是主要用于遍历Collection集合中的元素，Iterator对象也称为迭代器。
Iterator必须依赖于Collection对象，若有一个Iterator对象，则必然有一个与之关联的Collection对象。Iterator接口定义了三种方法：
hasNext（）：如果被迭代的元素还没有被遍历，则返回true
nest（）：返回集合上一次next方法返回的元素
remove（）：删除上一次next方法返回的元素
Iteractor和for的区别
①采用 ArrayList 对随机访问比较快，而 for 循环中的 get()方法，采用的即是随机访问的方法，因此在 ArrayList 里，for 循环较快。采用 LinkedList 则是顺序访问比较快，iterator 中的 next()方法，采用的即是顺序访问的方法，因此在 LinkedList 里，使用 iterator 较快。 ② for 循环适合访问顺序结构 ,可以根据下标快速获取指定元素.而 Iterator 适合访问链式结构,因为迭代器是通过 next()和 Pre()来定位的 .可以访问没有顺序的集合。
③使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整 ,因为 List 有序 ,Set 无序 ,结构不同,他们的访问算法也不一样。
注意：
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允许重复。
7.list中可以放任何东西，List允许有重复元素
8.ArrayList类似数组的形式进行存储，随机访问速度极快，相較於LinkedList 不適合拿來進行元素安插和移除動作，ArrayList是List接口的一个可变长数组实现。实现了所有List接口的操作，并允许存储null值。 除了没有进行同步，ArrayList基本等同于Vector。在Vector中几乎对所有的方法都进行了同步，但ArrayList仅对writeObject和readObject进行了同步，其它比如add(Object)、remove(int)等都没有同步。
由于ArrayList采用一个对象数组存储元素，所以在删除一个元素时需要把后面的元素前移。删除一个元素时只是把该元素在elementData数组中的引用置为null，具体的对象的销毁由垃圾收集器负责。
ArrayList的实现采用了动态数组，因此它的插入或者删除的效率会变得不好，但有很好的数据遍历性能。
9.LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作，对于查询的效率却是不好，可以在链表头尾增加、删除、插入元素
10.HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法，是把搜尋時間看的很重要的set
11.TreeSet存入的元素都會經過排列，所以速度比HashSet 慢一點
12.HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map
13.List TreeSet TreeMap有序，其中TreeSet和TreeMap用二叉树排序
14.HashSet是基于Hash算法实现的,其性能通常优于TreeSet,我们通常都应该使用HashSet,在我们需要排序的功能时,我们才使用TreeSet
集合指多个元素的聚集体。
Java中的集合类主要是由两个接口派生而出：
1):Collection接口: 存储一组对象,一次存一个元素, 是单列集合
Collection体系包括Set(无序集合，元素不可重复)，List(有序集合，元素可以重复)，Queue(队列集合)
Collection是java.util下的集合接口，是集合类的上级接口。
Collection提供了对集合对象进行基本操作的通用接口方法，它在Java类库中有很多具体的实现，
Collection的意义在于为各种具体的集合提供最大化的统一操作方式。
Collections是一个包装类，有关于集合操作的一系列静态方法，实现对各类集合的搜索，排序，线程安全化等操作。
2):Map接口:保存具有映射关系的数据,存储一些关键字/值对,是双列集合
Map体系包括map(保存具有映射关系的数据)
常见的集合类：
1.List结构的集合类
ArrayList类，LinkedList类，Vector类,Stack类
2.Map结构的集合类
HashMap类，HashTable类
3.Set结构的集合类
HashSet类，Tree类
4.Queue结构的集合类
Queue接口
1.对List集合遍历
1.Iterator
2.ListIterator
3.for+get+size
4.增强for
2.对Set集合遍历
1.Iterator
2.增强for
集合和数组的区别：
1：数组是固定长度的；集合可变长度的,可以动态增长的数据
2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
数组转集合：asList()方法
String[] arr ={"123","456","789"};
List<String> list = Arrays.asList(arr);
集合转数组：toArray()方法
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String[] arr = al.toArray(new String[al.size()]),
Collection 和 Collections的区别：
Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
collection是集合的根接口。
java.util.Collections是类。此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
集合框架中容器简单用法：
①List 集合元素是有序，不唯一：
ArrayList 低层是数组，替代了 Vector，查询速度快；
LinkedList 低层是链表，，增删速度快；
Vector 低层也是数组，速度很慢，已经过时；
②Set 集合元素是无序，唯一；
HashSet 低层是哈希表；
LinkedHashSet 是 HashSet 的子类
TreeSet 底层是二叉树,
③Map 集合（键值对）
HashTable 低层是哈希表，不存在 null 键和 null 值；
HashMap 低层是哈希表，存在 null 键和 null 值；
TreeMap 低层是二叉树
技巧：Array 是数组结构，有角标，查询速度很快。link 就是链表结构：增删速度快，而且有特有方法，addFirst 、 addLast、removeFirst()、removeLast()、getFirst()、getLast()。
hash 就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖 hashCode ，equals方法 tree 就是二叉树，就要想到排序，就想要用到比较。
ArrayList类:
定义： ArrayList arr = new ArrayList();
添加数据： arr.add(数据)
删除数据：arr.remove(数据)
取出数据
数据的类型 数据名 = （数据类型） arr.get（下标）
注意：没有使用泛型时，取出的数据需要强制转换。
2.List和Set的相同点在于它们都继承Collection,它们的不同点在于,List是一种有序的Collection，
* 可以按照索引来访问List中的元素，Set是一种不包含重复元素的Collection，只能有一个NULL元素.
*
* 3.Map有三种常用类，分别是HashMap，HashTable，TreeMap.
* HashMap的特点是，效率高，允许空值，线程不同步
* HashTable的特点是，效率低，不允许空值，线程同步
* TreeMap的特点是，所有元素保持一个固定的顺序，可用于Map集合中元素排序，不允许键对象是null
操作集合的工具类：Collections：（注意不是Collection）
1):Collections 是一个操作 Set、List 和 Map 等集合的工具类
2):Collections 中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法。
排序操作：
—reverse(List)：反转 List 中元素的顺序。
—shuffle(List)：对 List 集合元素进行随机排序。
—sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序。
—sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。
—swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换。
同步控制：
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，
从而可以解决多线程并发访问集合时的线程安全问题。
-- synchronizedCollection(Collection<T> c)
-- synchronizedList(List<T> c)
-- synchronizedMap(Map<T> c)
-- synchronizedSet(Set<T> c)
-- synchronizedSortedMap(SortedMap<T> c)
-- synchronizedSortedSet(SortedSet<T> c)
1. Interface Iterable 迭代器接口，
这是Collection类的父接口。实现这个Iterable接口的对象允许使用foreach进行遍历，也就是说，所有的Collection集合对象都具有"foreach可遍历性"。
这个Iterable接口只有一个方法: iterator()。它返回一个代表当前集合对象的泛型<T>迭代器，用于之后的遍历操作
1.1 Collection
Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。
Collection是一个接口，用以提供规范定义，不能被实例化使用
1) Set
Set集合类似于一个罐子，"丢进"Set集合里的多个对象之间没有明显的顺序。Set继承自Collection接口，不能包含有重复元素(记住，这是整个Set类层次的共有属性)。
Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，在加入一个新元素的时，如果这个新元素对象和Set中已有对象进行equals比较返回false，则Set就会接受这个新元素对象，否则拒绝。
因为Set的这个制约，在使用Set集合的时候，应该注意两点：
1) 为Set集合里的元素的实现类实现一个有效的equals(Object)方法、
2) 对Set的构造函数，传入的Collection参数不能包含重复的元素
1.1) HashSet
HashSet是Set接口的典型实现，HashSet使用HASH算法来存储集合中的元素，因此具有良好的存取和查找性能。
当向HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。
值得主要的是，HashSet集合判断两个元素相等的标准是两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法的返回值相等
1.1.1) LinkedHashSet
LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置，但和HashSet不同的是，它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。
当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。
LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet的性能，但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)
1.2) SortedSet
此接口主要用于排序操作，即实现此接口的子类都属于排序的子类
1.2.1) TreeSet
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
1.3) EnumSet
EnumSet是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，该枚举类型在创建EnumSet时显式、或隐式地指定。EnumSet的集合元素也是有序的，
它们以枚举值在Enum类内的定义顺序来决定集合元素的顺序
2) List
List集合代表一个元素有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List集合允许加入重复元素，因为它可以通过索引来访问指定位置的集合元素。List集合默认按元素
的添加顺序设置元素的索引
2.1) ArrayList
ArrayList是基于数组实现的List类，它封装了一个动态的增长的、允许再分配的Object[]数组。
2.2) Vector
Vector和ArrayList在用法上几乎完全相同，但由于Vector是一个古老的集合，所以Vector提供了一些方法名很长的方法，但随着JDK1.2以后，java提供了系统的集合框架，就将
Vector改为实现List接口，统一归入集合框架体系中
2.2.1) Stack
Stack是Vector提供的一个子类，用于模拟"栈"这种数据结构(LIFO后进先出)
2.3) LinkedList
implements List<E>, Deque<E>。实现List接口，能对它进行队列操作，即可以根据索引来随机访问集合中的元素。同时它还实现Deque接口，即能将LinkedList当作双端队列
使用。自然也可以被当作"栈来使用"
3) Queue
Queue用于模拟"队列"这种数据结构(先进先出 FIFO)。队列的头部保存着队列中存放时间最长的元素，队列的尾部保存着队列中存放时间最短的元素。新元素插入(offer)到队列的尾部，
访问元素(poll)操作会返回队列头部的元素，队列不允许随机访问队列中的元素。结合生活中常见的排队就会很好理解这个概念
3.1) PriorityQueue
PriorityQueue并不是一个比较标准的队列实现，PriorityQueue保存队列元素的顺序并不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序，这点从它的类名也可以
看出来
3.2) Deque
Deque接口代表一个"双端队列"，双端队列可以同时从两端来添加、删除元素，因此Deque的实现类既可以当成队列使用、也可以当成栈使用
3.2.1) ArrayDeque
是一个基于数组的双端队列，和ArrayList类似，它们的底层都采用一个动态的、可重分配的Object[]数组来存储集合元素，当集合元素超出该数组的容量时，系统会在底层重
新分配一个Object[]数组来存储集合元素
3.2.2) LinkedList
1.2 Map
Map用于保存具有"映射关系"的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value。key和value都可以是任何引用类型的数据。Map的key不允
许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。
关于Map，我们要从代码复用的角度去理解，java是先实现了Map，然后通过包装了一个所有value都为null的Map就实现了Set集合
Map的这些实现类和子接口中key集的存储形式和Set集合完全相同(即key不能重复)
Map的这些实现类和子接口中value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
1) HashMap
和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序。并且类似于HashSet判断两个key是否相等的标准也是: 两个key通过equals()方法比较返回true、
同时两个key的hashCode值也必须相等
1.1) LinkedHashMap
LinkedHashMap也使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，与key-value对的插入顺序一致(注意和TreeMap对所有的key-value进行排序进行区
分)
2) Hashtable: 是一个古老的Map实现类
2.1) Properties
Properties对象在处理属性文件时特别方便(windows平台上的.ini文件)，Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入到属性文
件中，也可以把属性文件中的"属性名-属性值"加载到Map对象中
3) SortedMap
正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类一样，Map接口也派生出一个SortedMap子接口，SortedMap接口也有一个TreeMap实现类
3.1) TreeMap
TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对(节点)时，需要根据key对节点进行排序。TreeMap可以保证所有的
key-value对处于有序状态。同样，TreeMap也有两种排序方式: 自然排序、定制排序
4) WeakHashMap
WeakHashMap与HashMap的用法基本相似。区别在于，HashMap的key保留了对实际对象的"强引用"，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收。
但WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃
圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对
5) IdentityHashMap
IdentityHashMap的实现机制与HashMap基本相似，在IdentityHashMap中，当且仅当两个key严格相等(key1 == key2)时，IdentityHashMap才认为两个key相等
6) EnumMap
EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值。创建EnumMap时必须显式或隐式指定它对应的枚举类。EnumMap根据key的自然顺序
(即枚举值在枚举类中的定义顺序)
Collections API的体系结构
集合是代表一组对象的单个对象。集合中的对象叫元素。集合用于处理多种类型对象的问题，所有的类型都有一个特殊的种类(也就是说，它们都是从一个共同父类继承来的)。
集合可用于保存，处理Object类型的对象。这允许在收集中贮存任何对象，还可以在使用对象前从集合中检索到它之后，使用正确的类型转换为我们所需要的对象类型。
在程序设计中经常会用到各种各样的数据结构，如：表、映射、清单、树、集合等。显然，这些数据结构都满足集合的定义。为了方便处理各种各样的数据结构，Java在Java.util包中提供了一组API。这组API中的大部分类都实现了Collection接口，因此，被称作Collections API。
API还包括诸如HashSet, ArraySet, ArrayList, LinkedList和Vector等等的类，它们实现这些接口。API还提供了支持某些算法的方法，如：排序，二进制搜索，计算列表中的最小和最大等。
List，Set,Map将所有的对象一律视为Object类型
Collection，List，Set，Map都是接口，不能实例化。继承自他们的ArrayList，HashTable,HashMap等是具体类，这些才能被实例化
关于Clooections，值针对集合类的一个帮助类，提供一系列静态方法来实现对集合的搜索，排序，线程安全化等操作，相当于array进行类似操作的类Arrays
如何选择容器:
• 在各种List中，最好的是以ArrayList作为默认选择，当插入，删除频繁时，使用LinkedList().
• 在各种Set中，HashSet通常由于HashTree(插入，查找)，只是当需要排序是，才用TreeSet
• 在各种Map中，HashMap用于快速查找
• 当元素固定时，最好使用Array，因为Array的效率是最高的。
Collection：表示一组各自独立的元素，通常拥有相同的套用规则。接口类：java.util.Collection
List和Set就由它派生，套用规则分别为：List必须以特定次序来持有各元素，而Set无法拥有重复的元素。
Collection接口中所定义的方法：
-- int size()
-- boolean isEmpty()
-- void clear()
-- boolean contains(Object ele)
-- boolean add(Object ele)
-- boolean remove(Object ele)
-- Iterator iterator()
-- boolean containsAll(Collection c)
-- boolean addAll(Collection c)
-- boolean removeAll(Collection c)
-- boolean retainAll(Collection c) 求交集
-- Object[] toArray()
集合根据它们处理的不同种类的数据结构，Collections API可分为三类：
(Collection)收集---没有具体顺序的一组对象
(Set)设定---没有重复的一组对象，(无序集合，元素不可重复)
(List)列表---有序对象组，允许重复(有序集合，元素可以重复)
集合框架中容器简单用法：
1):List 集合元素是有序，可重复，不唯一，每个元素都有其对应的顺序索引：默认按元素的添加顺序设置元素的索引
List 集合里添加了一些根据索引来操作集合元素的方法：
-- void add(int index, Object ele)
-- boolean addAll(int index, Collection eles)
-- Object get(int index)
-- int indexOf(Object obj)
-- int lastIndexOf(Object obj)
-- Object remove(int index)
-- Object set(int index, Object ele)
-- List subList(int fromIndex, int toIndex)
额外方法: listIterator()该方法返回一个 ListIterator 对象
1.1):ArrayList 底层是数组，替代了 Vector，查询速度快；
擅长随机访问元素，但在List中间插入，删除，移动元素较慢
定义： ArrayList arr = new ArrayList();
添加数据：arr.add(数据)
删除数据：arr.remove(数据)
取出数据：数据的类型 数据名 = （数据类型） arr.get（下标） 注意：没有使用泛型时，取出的数据需要强制转换。
1.2):LinkedList 底层是链表，增删速度快；
插入，删除，移动元素方便，随机访问元素差
特有方法: addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
1.3):Vector 底层也是数组，速度很慢，已经过时,不推荐使用，建议使用 ArrayList，虽然其线程安全。
2):Set 集合元素是无序，哈希值,唯一，加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。要覆盖 hashCode ，equals方法
2.1):HashSet 底层是哈希表；为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。
2.2):LinkedHashSet 是 HashSet 的子类, 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。
2.3):TreeSet 底层是二叉树, 保存次序的Set,使用它可以从Set中提取有序的序列。
3):Map集合:
map存储了一系列键值的映射关系，
map集合需要保证键值的唯一性
可以通过键值获得值，反之则不能
map集合存储元素使用put（key，value）方法
map集合的两种遍历方式
通过keySet方法返回由键组成的集合，迭代该集合的元素就拿到了所有的键，再调用get方法根据键拿到值
通过entrySet方法返回键值映射关系组成的集合，迭代该集合就拿到了一个个的聚氨酯映射关系，通过getKey方法拿到键
Map 集合（键值对）, 接口类：java.util.Map
用于保存具有映射关系的数据,key 和 value 都可以是任何引用类型的数据
严格的实现类只有HashMap和TreeMap，但另外还有两个也实现了该接口，即LinkedHashMap和HashTable。
null值可以作为键，但只能有一个，而可以有一个或多个键对应的value值为null，因此在HashMap中不能用get()方法来判断其是否存在某个key，应该用contains
执行效率是Map的一个大问题。看看get()要做哪些事，就会明白为什么在ArrayList中搜索“键”是相当慢的。而这正是HashMap提高速度的地方。HashMap使用了特殊的值，称为“散列码”(hash code)，来取代对键的缓慢搜索。“散列码”是“相对唯一”用以代表对象的int值，它是通过将该对象的某些信息进行转换而生成的。所有Java对象都能产生散列码，因为hashCode()是定义在基类Object中的方法。
Map 中的Key 不允许重复（值可以）,同一个 Map 对象的任何两个 Key 通过 equals 方法比较
Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value
3.1):HashTable 底层是哈希表，古老的 Map 实现类，线程安全,但不建议使用,不存在 null 键和 null 值；
线程安全，速度慢，不允许存放null值，已被HashMap取代。
3.2):HashMap 底层是哈希表，存在 null 键和 null 值；
线程不安全，存取速度快，允许存放null值。通过HashSet原理保证键的唯一性。
使用对象的hashCode()进行快速查询的。此方法能够显著提高性能。
在缺省情况下是非同步的，其同步问题可以通过Collections的静态方法来解决，如Map Collections.synchronizedMap(Map m)；
Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。
3.3):Properties：是HashSet的子类，所以他的线程也是安全的。
它用于读写配置文件，一般配置项等号两边都是String，所以该集合的两列保存的都是String类型的数据，这个集合只能存String，所以不需要定义泛型。
3.4):TreeMap 底层是二叉树,存储 Key-Value 对时，需要根据 Key 对 key-value 对进行排序
通过二叉树算法保证键的唯一性，它对键进行排序，排序原理与TreeSet原理相同。
TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
TreeMap 可以保证所有的 Key-Value 对处于有序状态
TreeMap 的 Key 的排序：
——自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException。
——定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口。
3.5):WeakHashMao : 弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。
3.6):IdentifyHashMap : 使用==代替equals()对“键”作比较的hash map。专为解决特殊问题而设计。
注意：
1):与HashSet 集合不能保证元素的顺序的顺序一样，Hashtable 、HashMap 也不能保证其中key-value 对的顺序;
2):Hashtable 、HashMap 判断两个 Key 相等的标准是：两个 Key 通过 equals 方法返回 true，hashCode 值也相等;
3):Hashtable 、HashMap 判断两个 Value相等的标准是：两个 Value 通过 equals 方法返回 true;
4):LinkedHashMap 是 HashMap 的子类,可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致;
Map常用方法：
-- void clear()
-- boolean containsKey(Object key)
-- boolean containsValue(Object value)
-- Set<Map,Entry<E,Y>> entrySet()
-- boolean equals(Object o)
-- V get(Object key)
-- int hashCode()
-- boolean isEmpty()
-- keySet()
-- put(key,value)
-- putAll()
-- remove()
-- int size()
-- values()
五，HashMap和HashTable的区别
相同点：都继承了Map接口的类
不同点：
HashMap类没有分类或者排序，她允许一个null键和多个null值
HashTable和HashMap一样，但是不允许null键和null值，他比hashMap慢，因为它是同步的
hashTable的是contains方法，而hashmap的是containskey和containsvalue方法
Iterator接口也是Java集合框架的成员，但它与Collection,Map体系不同，不是用于装载其它对象，而是主要用于遍历Collection集合中的元素，Iterator对象也称为迭代器。
Iterator必须依赖于Collection对象，若有一个Iterator对象，则必然有一个与之关联的Collection对象。Iterator接口定义了三种方法：
hasNext（）：如果被迭代的元素还没有被遍历，则返回true
nest（）：返回集合上一次next方法返回的元素
remove（）：删除上一次next方法返回的元素
Iteractor和for的区别
①采用 ArrayList 对随机访问比较快，而 for 循环中的 get()方法，采用的即是随机访问的方法，因此在 ArrayList 里，for 循环较快。采用 LinkedList 则是顺序访问比较快，iterator 中的 next()方法，采用的即是顺序访问的方法，因此在 LinkedList 里，使用 iterator 较快。 ② for 循环适合访问顺序结构 ,可以根据下标快速获取指定元素.而 Iterator 适合访问链式结构,因为迭代器是通过 next()和 Pre()来定位的 .可以访问没有顺序的集合。
③使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整 ,因为 List 有序 ,Set 无序 ,结构不同,他们的访问算法也不一样。
注意：
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允许重复。
7.list中可以放任何东西，List允许有重复元素
8.ArrayList类似数组的形式进行存储，随机访问速度极快，相較於LinkedList 不適合拿來進行元素安插和移除動作，ArrayList是List接口的一个可变长数组实现。实现了所有List接口的操作，并允许存储null值。 除了没有进行同步，ArrayList基本等同于Vector。在Vector中几乎对所有的方法都进行了同步，但ArrayList仅对writeObject和readObject进行了同步，其它比如add(Object)、remove(int)等都没有同步。
由于ArrayList采用一个对象数组存储元素，所以在删除一个元素时需要把后面的元素前移。删除一个元素时只是把该元素在elementData数组中的引用置为null，具体的对象的销毁由垃圾收集器负责。
ArrayList的实现采用了动态数组，因此它的插入或者删除的效率会变得不好，但有很好的数据遍历性能。
9.LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作，对于查询的效率却是不好，可以在链表头尾增加、删除、插入元素
10.HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法，是把搜尋時間看的很重要的set
11.TreeSet存入的元素都會經過排列，所以速度比HashSet 慢一點
12.HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map
13.List TreeSet TreeMap有序，其中TreeSet和TreeMap用二叉树排序
14.HashSet是基于Hash算法实现的,其性能通常优于TreeSet,我们通常都应该使用HashSet,在我们需要排序的功能时,我们才使用TreeSet
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
