java常用集合接口

1、接口 Collection<E>

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

方法摘要
boolean	add(E o)           确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extendsE> c)           将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear()           移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o)           如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o)           比较此 collection 与指定对象是否相等。
int	hashCode()           返回此 collection 的哈希码值。
boolean	isEmpty()           如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator()           返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o)           从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll(Collection<?> c)           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size()           返回此 collection 中的元素数。
Object[]	toArray()           返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

2、接口 Iterator<E>

对集合进行迭代的迭代器。

迭代器代替了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同：

      1、迭代器允许调用方利用定义良好的语义在迭代期间从迭代器所指向的集合移除元素。

      2、方法名称得到了改进。

方法摘要
boolean	hasNext()           如果仍有元素可以迭代，则返回 true。
E	next()           返回迭代的下一个元素。
void	remove()           从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。

3、接口 List<E>

          继承于Collection<E>, Iterable<E>

有序的 collection（也称为序列）。

此接口的用户可以对列表中每个元素的插入位置进行精确地控制，用户可以根据元素的索引（在列表中的位置）访问元素，也可以搜索列表中的元素。

与 set 不同，list通常允许重复的元素。比如：列表中若满足e1.equals(e2) 的元素，则同时允许存在e1 和e2，如果列表本身允许 null 元素的话，它们也允许多个 null 元素。

当然也有人尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，这种方式不是错误，但不被推荐。

方法摘要
boolean	add(E o)           向列表的尾部追加指定的元素（可选操作）。
void	add(int index, E element)           在列表的指定位置插入指定元素（可选操作）。
boolean	addAll(Collection<? extendsE> c)           追加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
boolean	addAll(int index, Collection<? extendsE> c)           将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
void	clear()           从列表中移除所有元素（可选操作）。
boolean	contains(Object o)           如果列表包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果列表包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)           比较指定的对象与列表是否相等。
E	get(int index)           返回列表中指定位置的元素。
int	hashCode()           返回列表的哈希码值。
int	indexOf(Object o)           返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。
boolean	isEmpty()           如果列表不包含元素，则返回 true。
Iterator<E>	iterator()           返回以正确顺序在列表的元素上进行迭代的迭代器。
int	lastIndexOf(Object o)           返回列表中最后出现指定元素的索引，如果列表不包含此元素，则返回 -1。
ListIterator<E>	listIterator()           返回列表中元素的列表迭代器（以正确的顺序）。
ListIterator<E>	listIterator(int index)           返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置开始。
E	remove(int index)           移除列表中指定位置的元素（可选操作）。
boolean	remove(Object o)           移除列表中出现的首个指定元素（可选操作）。
boolean	removeAll(Collection<?> c)           从列表中移除指定 collection 中包含的所有元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅在列表中保留指定 collection 中所包含的元素（可选操作）。
E	set(int index, E element)           用指定元素替换列表中指定位置的元素（可选操作）。
int	size()           返回列表中的元素数。
List<E>	subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Object[]	toArray()           返回以正确顺序包含列表中的所有元素的数组。
<T> T[]	toArray(T[] a)           返回以正确顺序包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        List<String> listTemp=new ArrayList<String>();
        list.add("tom");                
        System.out.println(list);                    //result is [tom]
        
        list.add(1, "jim");                
        System.out.println(list);                    //result is [tom, jim]
        
        list.contains("tom");            
        System.out.println(list.contains("tom"));    //result is true
        
        listTemp.add("jey");
        listTemp.add("joy");
        listTemp.addAll(list);
        System.out.println(listTemp);                //result is [jey, joy, tom, jim]
        
        System.out.println(listTemp.subList(1, 3));    //result is [joy, tom]
        System.out.println(listTemp.indexOf("tom"));//result is 2
        System.out.println(listTemp.lastIndexOf("tom"));//result is 2
        
        listTemp.retainAll(list);
        System.out.println(listTemp);                //result is [tom, jim]
        System.out.println(listTemp.isEmpty());        //result is false
        System.out.println(listTemp.size());        //result is 2
        
        String[] strs = listTemp.toArray(new String[]{});
        System.out.println("length is "+strs.length+",member is :"+strs[0]+"--"+strs[1]);        
        //length is 2,member is :tom--jim
    }

4、接口 Set<E>

一个不包含重复元素的 collection。更正式地说，set 不包含满足e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

方法摘要
boolean	add(E o)           如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean	addAll(Collection<? extendsE> c)           如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void	clear()           移除 set 中的所有元素（可选操作）。
boolean	contains(Object o)           如果 set 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)           如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean	equals(Object o)           比较指定对象与此 set 的相等性。
int	hashCode()           返回 set 的哈希码值。
boolean	isEmpty()           如果 set 不包含元素，则返回 true。
Iterator<E>	iterator()           返回在此 set 中的元素上进行迭代的迭代器。
boolean	remove(Object o)           如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean	removeAll(Collection<?> c)           移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean	retainAll(Collection<?> c)           仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int	size()           返回 set 中的元素数（其容量）。
Object[]	toArray()           返回一个包含 set 中所有元素的数组。
<T> T[]	toArray(T[] a)           返回一个包含 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

5、接口 Map<K,V>

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。

方法摘要
void	clear()           从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key)           如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)           如果此映射为指定值映射一个或多个键，则返回 true。
Set<Map.Entry<K,V>>	entrySet()           返回此映射中包含的映射关系的 set 视图。
boolean	equals(Object o)           比较指定的对象与此映射是否相等。
V	get(Object key)           返回此映射中映射到指定键的值。
int	hashCode()           返回此映射的哈希码值。
boolean	isEmpty()           如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet()           返回此映射中包含的键的 set 视图。
V	put(K key, V value)           将指定的值与此映射中的指定键相关联（可选操作）。
void	putAll(Map<? extendsK,? extends V> t)           从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key)           如果存在此键的映射关系，则将其从映射中移除（可选操作）。
int	size()           返回此映射中的键-值映射关系数。
Collection<V>	values()           返回此映射中包含的值的 collection 视图。

6、接口 SortedMap<K,V>

保证按照键的 升序排列的映射。

方法摘要
Comparator<? superK>	comparator()           返回与此有序映射关联的比较器，如果使用键的自然顺序，则返回 null。
K	firstKey()           返回有序映射中当前第一个（最小的）键。
SortedMap<K,V>	headMap(K toKey)           返回此有序映射的部分视图，其键值严格小于 toKey。
K	lastKey()           返回有序映射中当前最后一个（最大的）键。
SortedMap<K,V>	subMap(K fromKey,K toKey)           返回此有序映射的部分视图，其键值从 fromKey（包括）到 toKey（不包括）。
SortedMap<K,V>	tailMap(K fromKey)           返回有序映射的部分视图，其键大于或等于 fromKey。

7、接口 SortedSet<E>

保证迭代器按照元素递增顺序遍历的集合

方法摘要
Comparator<? superE>	comparator()           返回与此有序集合关联的比较器，如果使用元素的自然顺序，则返回 null。
E	first()           返回此有序集合中当前第一个（最小的）元素。
SortedSet<E>	headSet(E toElement)           返回此有序集合的部分视图，其元素严格小于 toElement。
E	last()           返回此有序集合中最后一个（最大的）元素。
SortedSet<E>	subSet(E fromElement,E toElement)           返回此有序集合的部分视图，元素范围从 fromElement（包括）到 toElement（不包括）。
SortedSet<E>	tailSet(E fromElement)           返回此有序集合的部分视图，其元素大于或等于 fromElement。