标签：
//学习方法，不要因为一点小问题而导致大技术的学习。
//学习方法不在于听，而在做，并坚持。节省时间必须要敲代码。
一、Collection 接口（子接口：Set 、 List）
★ Collection体系的共性方法（比特有方法还重要）
(1) 【添加】操作
boolean add(Object o):将对象添加给集合
boolean addAll(Collection c) : 添加c 中所有元素给集合
(2) 【判断】操作
boolean contains(Object o) ：判断集合中是否含有对象o
boolean containsAll(Collection c): 判断集合中是否含有集合c 中所有元素
boolean isEmpty() ：判断集合中是否有任何元素
(3) 【删除】操作
boolean remove(Object o): 如果集合中有与o相匹配的对象，则删除对象o
★ void removeAll(Collection c) : 从集合中删除集合c 中的【包含】元素
void clear(): 删除集合中所有元素，和remove一样都会改变集合的长度
★ void retainAll(Collection c) : 从集合中删除集合c 中【不包含】的元素（取交集）
(4) 【获取】操作
★ Iterator iterator() ：返回一个迭代器，用来访问集合中的各个元素
int size() ：返回当前集合中元素的数量（和Map一样，用的是size方法）
(5) 转换为Object数组（目的，转为数组后可防止对集合进行增删操作）
★ Object[] toArray() ：返回一个内含集合所有元素的array
<T> T[] toArray(T[] a)：此方法需要传入一个数组对象，如果此数组的长度小于集合的size，那么该方法会创建一个同类型、长度和集合size相同的数组，并依次存储集合中的元素；如果长度大于集合的size，则创建一个同类型同长度的数组，其他位置为null。
1、List 接口（继承Collection，元素允许重复，有序）
★ (1) 【基本】操作，List 继承了Collection的所有方法，并提供了基于【位置】的特有方法
Object get(int index): 返回List中指定位置的元素
int indexOf(Object o): 返回第一个出现元素o的位置，否则返回-1
int lastIndexOf(Object o) ：返回最后一个出现元素o的位置，否则返回-1
Object remove(int index)：删除指定位置上的元素
Object set(int index, Object element) ：取代指定位置元素，并返回旧的元素
List subList(int fromIndex, int toIndex) 返回指定范围子序列，包含首不包含尾
(2) 【迭代器】操作（同样具有返回Iterator的iterator方法）
★ ListIterator listIterator() : 返回一个列表迭代器，用来访问列表中的元素
ListIterator listIterator(int index) : 返回一个从指定位置开始访问列表中元素的迭代器
1.1、ArrayList类（实现List 接口，查询速度快，可理解为"大小可变的数组"）
允许包括 null 元素，可操作内部用来存储列表的数组的大小，特有方法了解即可,。
(1) void ensureCapacity(int minCapacity): 将ArrayList对象容量增加minCapacity
void trimToSize(): 整理（减小）ArrayList对象容量为列表当前大小
(2) ArrayList初始化时不可指定容量，如果以new ArrayList()方式创建时，初始容量为10个； 当向ArrayList中添加一个元素时，先进行容器的容量调整，如果容量不够时，则增加至原来 的1.5倍加1，再然后把元素加入到容器中，即以原始容量的0.5倍比率增加。
1.2、LinkedList类（实现List 接口，删除与插入速度快，可理解为"双向链表"）
(1) LinkedList采用双向链表来实现，类似堆栈（先进后出，FILO）或者队列（先进先出FIFO）数据结构，适合于元素的插入与删除操作。
★ (2) LinkedList类添加了一些处理列表【两端元素】的方法
void addFirst(Object o): 将对象o添加到列表的开头
void addLast(Object o)：将对象o添加到列表的结尾
Object getFirst(): 获取开头的元素，如果链表为空，抛出异常
Object getLast(): 获取结尾的元素，如果链表为空，抛出异常
Object peekFirst();获取开头的元素，如果链表为空，返回null
Object peekLast():获取结尾的元素，如果链表为空，返回null
Object removeFirst(): 获取并移除，如果链表为空，抛出异常
Object removeLast():获取并移除，如果链表为空，抛出异常
Object pollFirst();获取并移除，如果链表为空，返回null
Object pollLast();获取并移除，如果链表为空，返回null
(3) ArrayList 和 LinkedList 优缺点
ArrayList：是用数组实现的（类似数列），适合于随机访问，【读取】速度快，插入与删除速度慢（因为插入与删除时要移动后面所有的元素）。
LinkedList：双向链表来实现，【删除与插入】速度快，读取速度较慢，因为它读取时是从头向尾或从尾向头查找元素。如果要频繁的从列表的中间位置添加和除去元素，而只要顺序的访问列表元素，那么，LinkedList 实现更好。
2、Vector类（实现Collection接口，应用于多线程，增删改查都很慢，不建议使用）
(1) 功能、结构等与ArrayList几乎相同，但添加，删除，读取，设置都是基于线程同步的。
(2) Vector初始化时容量可以设定，如果以new Vector()方式创建时，则初始容量为10，超过 容量时以2倍容量增加。
(3) Vector中的迭代器既可以用Iterator，也可以用【Enumeration】
//*****************************************************************************************
3、Set 接口（继承Collection，元素不允许重复（核心特点），无序(也可以实现有序)）
Set接口中的方法和Collection一致
3.1、HashSet类（无序，实现Set接口，内部数据结构是HashMap，可理解为数学中的"集合"）
★ (1) HashSet如何保证集合元素的唯一性？
是通过【对象的】hashCode和equals方法来完成对象唯一性判断的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
(2) 一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals和hashCode方法，建立判断各自类的对象是否相同的依据。
比如两个对象，(ab,1)与(ab,1)，若直接用Object的hashCode方法（不同的对象返回不同的整数），则(ab,1)与(ab,1)的hashCode值并不一致，equals（即==）结果也为false。
(3) 注意：最常用的String类已经重写了这两个方法(StringBuilder、StringBuffer没有)
3.1.1、LinkedHashSet类（有序，继承HashSet，可理解为数学中的"一次函数"）
和HashSet相比，区别就是有序，其迭代器按照元素的插入顺序来依次访问各个元素
3.2、TreeSet类（有序，实现Set和SortedSet接口，内部数据结构是二叉树(TreeMap)）
★ (1) 两种构造函数
TreeSet() 构造一个新的空 set，该 set 根据其元素的自然顺序进行排序，注意，采用此种方式构造TreeSet，自定义对象必须重写Comparable接口的compareTo方法。
TreeSet(Comparator c): 构造一个空TreeSet，它根据指定比较器对象c进行排序
★ (2) TreeSet对元素进行排序的实现方式
方式一：让元素自身具备比较功能，元素需实现Comparable接口的compareTo方法
(注意，String类及基本类型包装类已重写此方法，均按自然顺序进行排序)
方式二： 让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare 方法，将该类对象作为参数传递给TreeSet集合的构造函数。
(3) 若以上两种方式同时存在，则以集合自身具备的比较功能为准
//*****************************************************************************************
//*****************************************************************************************
二、Map接口（和Collection都是顶层接口，类似数学中的"函数"(x是唯一的，y可重复)）
特点： Map一次添加一对元素，Collection 一次添加一个元素； Map也称为双列集合，Collection也称为单列集合；Map中存储的是键值对，必须保证键的唯一性。
★ Map体系下个常用共性方法：
1，添加。
★ value put(key,value):返回前一个和key关联的值，如果没有返回null.
2，删除。
void clear():清空map集合
★ value remove(key):如果存在一个键的映射关系，则将其从此映射中移除，并返回此映射 中以前关联该键的值，如果此映射不包含该键的映射关系，则返回null
3，判断。
boolean containsKey(key):
boolean containsValue(value):
boolean isEmpty();
4，获取。
★ value get(key):通过键获取值，如果没有该键返回null；可用来判断是否包含指定键
int size(): 获取键值对的个数
★ 5，遍历操作。
Set<K> keySet()：返回此映射中包含的【键】的【Set】视图
Collection<V> values()：返回此映射中包含的【值】的【Collection】视图
Set<Map.Entry<K,V>> entrySet()：返回此映射中包含的【映射关系】的【Set】视图
2.1、HashMap类: 无序，内部结构是哈希表，键不能重复，允许键或值为null。
★ 与HashSet一样，使用HashMap一般需要对【键类】重写其hashCode()和equals()方法
2.1.1、LinkedHashMap类：继承HashMap，以插入顺序将关键字/值对添加进链接哈希映像中。 与LinkedHashSet一样，LinkedHashMap内部也采用双重链接式列表。
2.2、TreeMap类: 有序，内部结构是二叉树，可以对Map集合中的【键】进行排序。
TreeMap实现Map和SortedMap接口，类似TreeSet类，添加到TreeMap类的元素的key必须实现Comparable接口，否则必须给它的构造函数提供一个Comparator接口的实现
★ (1) 构造方法
TreeMap():使用键的自然顺序构造一个新的、空的树映射
TreeMap(Comparator c): 构造一个使用比较器c对关键字进行排序的树映像
TreeMap(SortedMap s): 构造一个与指定有序映射s具有【相同映射关系】和【相同排序顺序】的新的树映射
(2) Comparator comparator(): 返回对【关键字】进行排序时使用的比较器，如果使用 Comparable接口的compareTo()方法对关键字进行比较，则返回null
(3) HashMap和TreeMap优缺点
需要在Map 中频繁插入、删除和定位元素，HashMap 更好。
但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap更好。
2.3、Hashtable类: 内部结构是哈希表，是同步的。不允许null作为键，null作为值。
2.3.1、Properties类：Hashtable的直接子类，是同步的。
properties文件是一种配置文件（ini、xml文件也是），文件类型为*.properties，格式为文本文件。文件的内容是"键=值"的格式，键和值都是字符串，用"#"标记作注释。常和IO技术相结合，集合中的数据可以保存到流(store)中，或者从流中获取(load)。
1.getProperty (key) ，通过key 得到value
2.setProperty (key, value) ，间接调用 Hashtable 的put方法来设置键-值对。
★ 3.load (InputStream/Reader) ，从【输入流】中读取属性列表(键和元素对)
★ 4.store (OutputStream/Writer, String) ，将键-值对写入到指定【输出流】关联的文件中
5.list(PrintStream/PrintWriter),将属性列表输出到指定的输出流。此方法对调试很有用。
6.stringPropertyNames(),返回属性列表中键的Set集合，包括默认属性列表中的键
//*****************************************************************************************
//*****************************************************************************************
三、Iterator接口（Collection均可生成此接口对象）
★ (1) 【遍历】操作
boolean hasNext(): 判断是否存在下一个可访问的元素
Object next(): 返回要访问的下一个元素。若无则抛出异常
(2) void remove(): 删除上次访问返回的对象。本方法必须紧跟在一个元素的访问后执行。如果上次访问后集合已被修改，方法将抛出IllegalStateException
2.1、ListIterator接口（ Iterator的子接口,List可生成此接口对象）
(1) 【正向遍历】
boolean hasNext(): 以正向遍历列表
Object next(): 返回下一个元素
int nextIndex(): 返回下次调用next方法时将返回的元素的索引
(2) 【逆向遍历】
boolean hasPrevious(): 以逆向遍历列表
Object previous()：返回上一个对象
int previousIndex(): 返回下次调用previous方法时将返回的元素的索引
★ (3) 【遍历时修改】
void add(Object o): 将对象o添加到当前位置的前面
void set(Object o): 用对象o替代next或previous方法访问的上一个元素
void remove() 从列表中移除由 next 或 previous 返回的最后一个元素
十、Enumeration接口（只提供了遍历 Vector 和 Hashtable类型集合元素的功能）
此接口的作用与 Iterator 接口类似，但不支持元素的移除操作，新的实现应该优先考虑使用 Iterator 接口。常用于将【输入流】指定到 SequenceInputStream 中。
(1) boolean hasMoreElements() 测试此枚举是否包含更多的元素。
E nextElement() 返回此枚举的下一个元素。
(2) 需注意，集合工具类的静态方法<T> Enumeration<T> enumeration(Collection<T>c)可以返回一个指定集合上的枚举。当需要枚举对象时应优先考虑通过这种方式获取。
(3) 另外，Hashtable的子类Properties的propertyNames方法可以返回所有健的枚举。
//*****************************************************************************************
//*****************************************************************************************
四、Comparable接口（让类自身具有排序功能）
(1) 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。建议最好使自然排序与 equals 一致。
(2) 实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
(3) int compareTo(Object o): 比较当前对象与对象o，如果位于对象o之前，返回负值；如果两个对象在排序中位置相同，则返回0；如果位于对象o后面，则返回正值
//*****************************************************************************************
//*****************************************************************************************
五、Comparator接口（作为参数传递）
(1) 对于那些没有实现Comparable接口的类（这些类一般不具有排序功能），若要存入Tree容器中，需通过另外定义一个类并使其实现 Comparator接口，从而定义一个比较器来定义您自己的比较方式。
(2) int compare(Object o1, Object o2): 比较两个对象，如果o1位于o2的前面，则返回负 值；如果o1位于o2的后面，返回正值；如果在排序顺序中认为o1和o2是相同的，返回0。
(3) 与Comparable相似，0返回值不表示元素相等，只是表示两个对象排在同一位置。
//*****************************************************************************************
//*****************************************************************************************
六、Map.Entry<K,V>接口
(1) Map的【entrySet()】方法返回一个实现Map.Entry接口的【Set】类型的对象【集合】，集合中每个对象都是底层Map中一个特定的【Map.Entry】类型的【键/值对】。
(2) 通过这个集合的迭代器，您可以获得每一个条目的键或值并对值进行更改。当条目通过迭代器返回后，除非是迭代器自身的remove()方法或者迭代器返回的条目的setValue()方法，其余对源Map外部的修改都会导致此条目集变得无效，同时产生条目行为未定义。
(3) Object getKey(): 返回条目的关键字
Object getValue(): 返回条目的值
Object setValue(Object value): 将相关映像中的值改为value，并且返回旧值
//*****************************************************************************************
//*****************************************************************************************
七、SortedMap<K,V>接口
(1) 类似SetMap，添加到SortedMap实现类（即TreeMap类）的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。
(2) Comparator comparator(): 返回对【关键字】进行排序时使用的比较器，如果使用Comparable接口的compareTo()方法对关键字进行比较，则返回null
(2) Object firstKey(): 返回映像中第一个(最低)关键字
Object lastKey(): 返回映像中最后一个(最高)关键字
SortedMap subMap(Object fromKey, Object toKey): 返回从fromKey(包括)至toKey(不包括)范围内元素的SortedMap视图(子集)
//*****************************************************************************************
//*****************************************************************************************
八、Collections类（集合类Collections的工具类，全部为静态方法）
1、【排序】sort(List)和sort(List,Comparator)和shuffle(List) (随机排序)
public static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素的自然顺序对指定列表按升序进行排序。列表中的所有元素都必须实现Comparable接口。此外，列表中的所有元素都必须是可相互比较的。
public static <T> void sort(List<T> list,Comparator<? super T> c)根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
2、【逆转】reverse()和reverseOrder()和reverseOrder(Comparator)
public static <T> Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
3、【二分搜索法】binarySearch(List,T)和binarySearch(List,T,Comparator)
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
使用二分搜索法搜索指定列表，以获得指定对象。在调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过sort(List) 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
public static <T> int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)
在调用之前，必须根据指定的比较器对列表进行升序排序（通过 sort(List, Comparator)方法）
4、【修改】replaceAll(List list,Object old,Object new)用new替换列表中所有的old
fill(List list,Object o) 用指定元素o替换集合中的所有元素
swap(List list,int i,int j) 交换列表指定位置处的元素
copy(List m,List n) 将集合n中的元素全部复制到m中,并且覆盖相应索引的元素
rotate(List list,int m) 集合中的元素向后移m个位置，在后面被遮盖的元素轮换到前面来
5、【最大值】max(Collection)和max(Collection,Comparator)
【最小值】min(Collection)和min(Collection,Comparator)
【查找首次】indexOfSubList(List source,List target) 查找首次出现位置的索引
【查找尾次】lastIndexOfSubList(List source,List target)
6、【转同步】synchronizedCollection/List/Map/Set (Collection/List/Map/Set)
//*****************************************************************************************
//*****************************************************************************************
九、Arrays类（数组类 [ ] 的工具类，全部为静态方法）
1、【排序】sort(arr) 由小到大排序
2、【二分搜索法】binarySearch(arr,key) 对数组进行二分搜索。这个排序算法是一个经过调优的快速排序法
若数组中存在此值，返回其索引；否则返回负值 (-(插入点) - 1)。注意：若存在多个，则不确定会找到哪个。
binarySearch(arr,fromIndex,toIndex,key)，包括from不包括to
使用前必须先使用sort(arr)方法对数组进行排序，如果没有对数组进行排序，则任何结果都是不明确的（也可能为负）
3、【填充】 fill(arr,val) 将数组的元素全部设定为指定的值
fill(arr,fromIndex,toIndex,val) 将数组的指定范围内的元素设定为指定的值，包括from不包括to
4、【判断相等】equals(arr1，arr2) ，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的
deepEquals(arr1，arr2)，与 equals(Object[],Object[]) 方法不同，此方法适用于任意深度的嵌套数组。
5、【复制】copyOfRange(arr, int from, int to) 将指定数组的指定范围复制到一个新数组，包括from不包括to
copyOf(arr, int newLength) 复制指定的数组，截取或用 0 (或false、或null字符)填充（如有必要），以使副本具有指定的长度。
System.arraycopy((Object src, int srcPos, Object dest, int destPos, int length) length - 要复制的数组元素的数量
从指定源数组(src)的指定位置(srcPos)开始，复制其元素到目标数组(dest)，从起始位置(destPos)开始共复制length个。
6、【字符串】toString(arr)返回数组内容的字符串表示形式。此字符串形式为："[元素], [元素], [元素] "（由逗号加空格分割）
deepToString(Object[] a) 返回数组“深层内容”的字符串表示形式。此方法是为了将多维数组转换为字符串而设计的。
如System.out.println( Arrays.deepToString( new int[][] { { 1, 3, 6 }, { 2, 7, 9 } } ) ); // [[1, 3, 6], [2, 7, 9]]
7、【哈希值】hashCode(arr)，基于指定数组的内容返回哈希码，如果 a 为 null，则此方法返回 0
deepHashCode(Object[] a) 基于指定数组的“深层内容”返回哈希码。
8、【数组转集合】public static<T> List<T> asList(T... a) （a - 支持列表的数组）
如果数组中的元素是对象（比如字符串），那么会将数组中的【元素】作为集合中的元素进行存储。
如果数组中的元素是基本类型数值，那么会直接将该【数组】作为集合中的一个元素进行存储。
此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
此方法同【Collection.toArray()】一起充当了基于数组的API与基于集合的 API 之间的桥梁
目的：转为集合后可以使用集合的方法操作数组中的元素。
注意：数组的长度是固定的，所以对于集合的增删方法是不能用的，否则运行时会抛出异常
//*****************************************************************************************
//*****************************************************************************************
//关键字特点：
看到【list】： 就要想到元素【可重复】
看到【array】：就要想到【数组】，查询快，有【角标】★
看到【link】：就要想到【链表】，增删快，有操作【frist last】的方法
看到【set】:就要想到【唯一性】，元素不可重复
看到【hash】:就要想到【哈希表】，【查询快】，要重写【hashcode和equals】方法★
看到【tree】：就要想到【二叉树】，【要排序】，要实现【Comparable或Comparator】★
看到【map】：就要想到【键值对】，键唯一
//选择依据：
需要存储键值对还是单个值？
键值对： Map （健是Integer时可考虑数组或ArrayList集合）
需要指定（健的）顺序吗？
需要： TreeMap
不需要： HashMap
但想要一个和存储一致的顺序(有序):LinkedHashMap
值： Collection
需要元素唯一吗？
需要： Set
需要制定指定顺序吗？
需要： TreeSet
不需要： HashSet
但想要一个和存储一致的顺序(有序):LinkedHashSet
不需要： List
需要频繁增删吗？
需要： LinkedList
不需要： ArrayList
//对List的选择（ArrayList）:
对于【随机查询】与【迭代遍历】操作，数组ArrayList比所有的容器都要快。
从【中间】的位置【插入和删除】元素，LinkedList要比ArrayList快，特别是删除操作。
Vector通常不如ArrayList快，则且应该避免使用，它目前仍然存在于类库中的原因是为了支持过去的代码。
最佳实践:将ArrayList作为默认首选，仅当程序的性能“由于需要经常从list中间进行插入和删除”而变差的时候，才选择LinkedList。
//对Set的选择（HashSet）:
HashSet的性能总比TreeSet好(特别是最常用的【添加和查找】元素操作)。
TreeSet存在的唯一原因是，它可以维持元素的【排序】状态，所以只有当你需要一个排好序的Set时，才应该使用TreeSet。
对于插入操作，LinkedHashSet比HashSet略微慢一点：这是由于维护链表所带来额外开销造成的。不过，因为有了链表，【遍历】LinkedHashSet会比HashSet更快。
//对Map的选择（HashMap）:
TreeMap通常比HashMap慢，因为要维护排序。
LinkedHashMap比HashMap慢一点，因为它同时还要维护链表。
Hashtable和HashMap的效率大致相同，通常HashMap会更快一点，所以HashMap有意取代Hashtable。
HashMap正是为【快速查询】而设计的。
//hashCode与equals
重写hashCode与equals这两个方法是针对哈希系列集合，至于其它集合，如果要用contains()方法查找时，只需实现equals()方法即可，他们都只使用对象的 equals方法进行比对，没有使用 hashCode方法。
标签：
原文地址：http://www.cnblogs.com/bqtt/p/4729682.html
