总结一下java里的Collections

java 的集合类包含两部分,一部分是实现了接口Collection的类,另一部分是实现了接口Map的类.注意虽然后者没有实现Collection接口,但是它们都是Collections(不是Collection)的一部分.
下面的内容基于jdk1.5以上.其中用到了泛型.
下面之所以列出它们的方法,是为了让大家了解一下它们的规律
先看实现了Collection的类.
它的方法主要可以分为:1.添加,删除 2.查询 3.其他
1.添加,删除: boolean add(Object),boolean addAll(Collection<? extends E>)
       boolean remove(Object) ,boolean removeAll(Collection<?>),boolean retainAll(Collection<?>),void clear()
2.查询. 查询操作不能直接进行,而只能通过Iterator来操作.方法iterator()用来返回一个作为内部类实现的Iterator<T>.用返回的这个Iterator的hasNext()和next()来进行查询集合里的内容.
3.其他 有查询大小的size(),有将集合转换为数组的Object[] toArray()和<T> T[] toArray(T[]),还有从Object类继承过来的equals()和hashCode(),还有判断是不是空的isEmpty(),boolean contains(Object o),boolean containsAll(Collection<?> c)  
总共15个方法

1.再来看它的子接口List<T>
List<T>的主要特点(这些特点是相对于Collection的另一子接口Set<T>来说的)是它可以存放重复的元素,而且里面的元素是按序存放的.基于这些特点,List<T>除了上面从Collection继承过来的方法以外,还增加了以下根据索引添加删除的方法:
add(int index,Object),addAll(int index,Collection<? extends E> c)
remove(int index)
因为有了索引,所以查询可以直接进行,而不必通过Iterator<T>了
get(int index),set(int index,E element)
indexOf(Object) lastIndexOf(Object)
ListIterator<E> listIterator(),ListIterator<E> listIterator(int index)
 ListIterator<E>相对于Iterator<E>来说,多了从后往前遍历的功能.所以它又多了previous(),hasPrevious()两个主要方法.另外还有
 nextIndex()和previousIndex();以及set(E o),remove();
List<E> subList(int fromIndex, int toIndex) 
再来看实现了List<T>的类
1.1 ArrayList<T>
它在List<T>的基础上增加了以下方法:
void ensuerCapacity( int minCapacity )
void trimToSize()
Object clone() 
protected void removeRange(int from, int to)
ArrayList<T>的特点(相对于下面要说到的其他List<T>实现类)是元素在里面是按添加的顺序存放的
1.2 LinkedList<T>
它和ArrayList<T>一样,元素在里面是按添加的顺序存放的.在随机获得元素方面相对慢一点,而在添加删除元素方面,它比ArrayList<T>要快.因为它有以下的方法:
void addFirst(Object),void addLast(Object),E removeFirst(),E removeLast()
E getFirst(),E getLast()
 E element() 找到但不移除此列表的头（第一个元素）。 
 E peek()  找到但不移除此列表的头（第一个元素）。 
 E poll()  找到并移除此列表的头（第一个元素）。 
 boolean offer(E o)  将指定元素添加到此列表的末尾（最后一个元素）。 
1.3 Vector<T>
这个还是和上面两个类有着同样的特点,即可以存放重复的元素,元素在里面是按添加的顺序存放的.不同的是,这个类的实现是线程安全的.在修改,移除,添加和获取元素四种操作上,它在LinkedList<T>的基础上(但它不是LinkedList<T>的子类.这里说在"它的基础上",只是因为它们的方法有很多的相似)增加了一些方法,这些方法在名字,参数顺序和返回值都不同,但是功能是一样的
修改:void setElementAt(E,int index)[E set(int index,E o)]
移除:void removeElementAt(int index)[E remove(int index)]
添加:void insertElementAt(E, int index)[E add(int index,E o)]
void addElement(E o)
boolean removeElement(Object)
void removeAllElements()
获取:
E elementAt(int index)[E get(int index)]
 E firstElement() ,E lastElement()
方括号里的是List<T>里定义的方法
以上三个类都有一个无参的和一个以Collection<? extends E> c为参数的构造函数

List<T>还有其他一些实现类,这里就不说了.
下面来看Set<T>
Set<T>的特点和数学上的集合一样,不可以存放重复的元素,这也是它和List<T>的不同.它和List<T>的另一个不同是,它的实现类大多以有序的方式存放元素,而不是以添加元素的顺序存放.
Set<T>的方法都是从它的父接口Collection<T>继承过来的
下面来看它的实现类
2.1 HashSet<E>
它按元素的hashCode()来对元素进行降排序之后进行有序存放
它的方法都是在接口Set<E>里的
2.1.1 LinkedHashSet<E>
如果要按添加顺序存放元素,就可以用这个类.LinkedHashSet<E>是HashSet<E>的子类
2.2 SortedSet<E>
这是一个接口,不是一个类.它的功能是,可以通过Comparator<E>类或Comparable<E>接口自定义元素的存放顺序.
它的方法除了从父接口继承过来的以外,还有:
Comparator<E> comparator()
E first(),E last()
SortedSet<E> headSet(E toElement),SortedSet<E> tailSet(E fromElement)
SortedSet<E> subSet(E toElement,E fromElement)
2.2.1 TreeSet<E>
SortedSet<E>的实现类,它的方法都是从接口SortedSet<E>继承过来的
2.3 EnumSet<E>
这是一个和枚举类型一起使用的专用的Set<E>的实现类
它没有构造函数,而且它的所有方法都是static的.
它的方法有:
<E extends EnumSet<E>> EnumSet<E> allOf( Class<E> elementType )
<E extends EnumSet<E>> EnumSet<E> noneOf( Class<E> elementType )
<E extends EnumSet<E>> EnumSet<E> complementOf( EnumSet<E> enumSet )
<E extends EnumSet<E>> EnumSet<E> copyOf( EnumSet<E> enumSet )
<E extends EnumSet<E>> EnumSet<E> copyOf( Collection<E> c )
<E extends EnumSet<E>> EnumSet<E> of( E e)
<E extends EnumSet<E>> EnumSet<E> of( E e1,E e2) 
<E extends EnumSet<E>> EnumSet<E> of(E first, E... rest) 
<E extends EnumSet<E>> EnumSet<E>  range(E from, E to)

Collection的子接口和实现类到此告一段落,现在来看Map<K,V>
Map<K,V>的功能是实现从键到值的映射.和Set<E>一样,它不可以包含重复的键(键所映射的值可以相同)
它的方法有:
添加:
V put(K key,V value)
void putAll(Map<? extends K,? extends V> t)  
删除:
V remove(Object key),void clear()  
查询:
V get(Object key)  
与Collection<E>的转换:
Set<K> keySet() ,Collection<V> values() 
注意前面说过,它不能包含重复的键,而键所映射的值可以相同.所以这里对键返回没有重复元素的Set接口,而对value返回可以有重复元素的Collection<E>
Set<Map.Entry<K,V>> entrySet() 
 一个Map.Entry<K,V>类实例代表着一个键值映射 .它的方法有:
 boolean equals(Object o) 
  K getKey() 
  V getValue() 
 int hashCode() 
 V setValue(V value) 
Map<K,V>的其他方法:
boolean containsKey(Object key) ,boolean containsValue(Object value)  
boolean equals(),int hashCode(),boolean isEmpty()
int size()

下面来看Map<K,V>的实现类
1.1 HashMap<K,V>
它对应于HashSet<E>,特点也一样,就是元素的存放顺序是按键值的降序存放的
它的方法都是从Map<K,V>继承过来的
1.1.1 LinkedHashMap<K,V>
它对应于LinkedHashSet<E>,特点也是元素是按添加顺序存放的
1.2 SortedMap<K,V>
它对应于SortedSet<E>,通过Comparator<E>类或Comparable<E>接口自定义元素的存放顺序.
方法也和SortedSet<E>一样,基本上只要将方法里的set换成map就行了,如下:
Comparator<E> comparator()
K firstKey(),K lastKey()
SortedMap<K,V> headMap(K toKey),SortedMap<K,V> tailSet(K fromKey)
SortedMap<K,V> subMap(K toKey,E fromKey)
1.2.1 TreeMap<K,V>
对应于TreeSet<E>,SortedMap<K,V>的实现类,它的方法都是从接口SortedMap<K,V>继承过来的
1.3 EnumMap<K extends Enum<K>,V>
主要的特点是,它的键必须是某一枚举类型的元素

Map<K,V>还有很多的其他实现类,这里就不说了

另外还有两个类要注意: Collections类和Arrays类
这里只说一下Arrays类:
它主要用于对数组进行操作.它的方法都是static的,它有几大类的方法
1.查找
int binarySearch(T[] a,T valueToFind)
其中T可以是任何原生类型或类类型
另外,还可以指定比较器,
<T> int binarySearch(T[] a, T key, Comparator<? super T> c) 
2.填充 
对数组进行填充
void fill(T[] a,T value)
其中T可以是任何原生类型或类类型
还可以指定填充范围
void fill(T[] a, int fromIndex, int toIndex, T val) 
3.比较两数组是否包含完全一样的元素
boolean equals(T[] a,T[] b )
4.对数组进行排序
void sort( T[] a )
void sort( T[] a ,int fromIndex, int toIndex)
void sort( T[] a ,Comparator c)
void sort( T[] a ,int fromIndex, int toIndex,Comparator c)
其中T可以是任何原生类型
5.将数组转换为字符串
String toStrint(T[] a)
其中T可以是任何原生类型
6.将数组转换为List<E>
<T> List<T> asList(T... a)

原文地址：http://xxkkff.blog.51cto.com/162016/26227