Java集合类

1，数组

使用数组前，必须初始化。初始化时必须指定大小，一经指定，不可改变。

int[] is；//只是声明一个数组引用，没有初始化
int[] is=int[3]；//初始化，显性指定大小，未指定内容
int[] is=new int[]{1,2,3}；//初始化内容，隐性指定大小

Arrays类方法

拷贝	static <T>[] copyOf(<T>[] a, int length)	常用来扩增数组大小，如：arr = Arrays.copyOf(arr, 2*arr.length);
排序	static void sort(<T>[] a)
二分搜索	static int binarySearch(<T>[] a,T key)	需要有序状态
转List	static List asList(Object...a)	返回的List不可变

2，集合框架

实际应用时，很难给出固定不变的大小。这时就需要使用集合类。集合类在java.util包。

集合类存放的都是对象的引用，而非对象本身。

1>Collection接口：存放多个元素。Set，List，Queue和Deque接口均继承自它。接口方法：

添加元素	boolean add(Object o) boolean addAll(Collection c)
删除元素	boolean remove(Objeot o) boolean removeAll(Collection c) void clear()
查找元素	boolean contains(Object o) boolean containsAll(Collection c)
元素个数	int size() boolean isEmpty()
遍历元素	Iterator iterator()
与其他集合取交集	boolean retainAll(CoIIection c)
转数组	Object[] toArray()

a>Set接口：不允许元素重复。是否重复是根据元素的equal()方法判断的。HashSet和TreeSet是两个主要的实现类。

HashSet是基于HashMap实现的，元素是无序的，不允许插入null。

LinkedHashSet也是基于HashMap实现的，由于维护了双向列表，因此元素是按照插入顺序排列的。继承自HashSet，因此不允许插入null。

TreeSet是基于TreeMap实现的，元素是有序的。元素必须实现Comparable接口。默认按照自然顺序排序，可通过构造函数指定comparetor。TreeSet提供了额外的方法：

首尾操作	E first() E last() E pollFirst() E pollLast()
根据大小比较获取元素的操作	E lower(E e) E floor(E e) e E ceiling(E e) E higher(E e)
根据大小比较获取一批元素的操作	SortedSet<E> headSet(E toElement) NavigableSet<E>  headSet(E toElement, boolean inclusive) e NavigableSet<E> tailSet(E fromElement, boolean inclusive) SortedSet<E> tailSet(E fromElement)
根据起始元素获得一批元素的操作	SortedSet<E> subSet(E fromElement, E toElement) NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
反向及反向遍历	NavigableSet descendingSet() Iterator descendingIterator()

b>List接口：允许元素重复。List接口添加了根位置有关的方法，以及反向遍历接口。ArrayList，Vector，Stack和LinkedList是主要的实现类。

获取元素位置	int indexOf(Object o) int lastIndexOf(Object o)
按位置获取元素	E get(int index)
按位置添加元素	void add(int index, E element) boolean addAll(int index, Collection<? extends E> c)
按位置删除元素	E remove(int index)
按位置替换元素	E set(int index, E element)
按位置取子List	List subList(int fromIndex, int toIndex)
反向遍历元素	ListIterator<E> listIterator() ListIterator<E> listIterator(int index)

ArrayList是基于Array实现的，适合频繁查询。添加了批量删除和控制容量的方法：

按起始位置批量删除元素	protected void removeRange(int fromIndex, int toIndex)
一次性获取容量，防止频繁添加	void ensureCapacity(int minCapacity)
减少多余容量	void trimToSize()

Vector也是基于Array实现的，但是同步的，新增方法(没有显示Element相关的方法，因为和List接口方法重复)：

容量相关	int capacity() void ensureCapacity(int minCapacity) void setSize(int newSize) void trimToSize()
遍历	Enumeration<E> elements()
转Array	void copyInto(Object[] anArray)

Stack继承自Vector，也是同步的，添加了模拟先进后出的堆栈的方法：

栈顶添加	E push(E item)
栈顶弹出	E pop()
取栈顶	E peek()
判栈空	boolean empty()
元素离栈顶距离	int search(Object o)

LinkedList是基于链表实现的，适合频繁添加。它同时还实现了Queue接口和Deque接口。

c>Queue接口：队列数据结构，先进先出。LinkedList和PriorityQueue是两个主要实现类。接口方法：

	失败后抛Exception	失败后返回特定值(false or null)
队列尾部添加	void add(Object e)	boolean offer(Object e)
队列头部删除	Object remove()	Object poll()
队列头部获取	Object element()	Object peek()

PriorityQueue是按从小到大的顺序规定队列顺序。可通过构造函数参数制定comparator。不允许null和不可比较的对象插入。

d>Deque接口：双向队列数据接口，支持双向头尾操作。主要实现类是LinkedList和ArrayDeque。接口方法：

	失败后抛Exception	失败后返回特定值
头部添加	addFirst(e)	offerFirst(e)
头部删除	removeFirst()	pollFirst()
头部获取	getFirst()	peekFirst()
尾部添加	addLast(e)	offerLast(e)
尾部删除	removeLast()	pollLast()
尾部获取	getLast()	peekLast()

Iterator<E> descendingIterator()获得反向iterator

e>Iterator接口统一了Collection的遍历方式，有如下方法：

查看下面是否还有元素	boolean hasNext()
返回下一个元素	Object next()
删除上一次next()返回的元素	void remove()

局限性：遍历时不可添加，替换元素。并且方向固定。

ListIterator接口提供了修改集合的方法，并且方向为双向，还能获得元素索引。但只有List才能使用。有如下方法：

查看下面是否还有元素	boolean hasNext() boolean hasPrevious()
返回下一个元素	Object next() Object previous()
元素索引	nextIndex() previous()
添加一个元素下一个元素之前	add(E e)
删除上一次返回的元素	void remove()
替换上一次返回的元素	set(E e)

2>Map接口：key:value的映射集合，key不能重复，value可以重复。HashMap，Hashtable，LinkedHashMap和TreeMap是主要的实现类。

添加键值对	V put(K key, V value) void putAll(Map<? extends K,? extends V> m)
根据key获得value	V get(Object key)
删除键值对 清空	V remove(Object key) void clear()
根据key查找 根据value查找	boolean containsKey(Object key) boolean containsValue(Object value)
获取大小 判空	int size() boolean isEmpty()
获取key集合 获取value集合 获取键值对集合	Set<K> keySet() Collection<V> values() Set<Map.Entry<K,V>> entrySet()

HashMap使用哈希表实现的，可设置initialCapacity(default 16)和loadFactor(0.75)，减少rehash次数。不是同步的。key和value能为null。

LinkedHashMap也是用哈希表实现的，也可设置initialCapacity和loadFactor。不是同步的。但维护了EntrySet的双向链表，因此会按照插入顺序保存。key和value能为null。

Hashtable也是使用哈希表实现的，也可设置initialCapacity和loadFactor。但是同步的，并且key须要有hashCode()和equals()方法。key和value 不能为null。

TreeMap使用红-黑树实现，根据key的顺序存取，key元素必须可比较。不是同步的。增加了方法：

	K	Map.Entry
首位操作	K firstKey() K lastKey()	Map.Entry<K,V> firstEntry() Map.Entry<K,V> lastEntry() Map.Entry<K,V> pollFirstEntry() Map.Entry<K,V> pollLastEntry()
根据大小比较获得元素	K lowerKey(K key) K floorKey(K key) K K ceilingKey(K key) K higherKey(K key)	Map.Entry<K,V> lowerEntry(K key) Map.Entry<K,V> floorEntry(K key) K Map.Entry<K,V> ceilingEntry(K key) Map.Entry<K,V> higherEntry(K key)
根据大小比较获取一批元素		SortedMap<K,V> headMap(K toKey) NavigableMap<K,V> headMap(K toKey, boolean inclusive) K NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) SortedMap<K,V> tailMap(K fromKey)
根据起始元素获得一批元素		NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) SortedMap<K,V> subMap(K fromKey, K toKey)
反向	NavigableSet<K> descendingKeySet()	NavigableMap<K,V> descendingMap()

并发：

标注为Legacy的集合，支持并发操作。Java5.0添加了支持并发操作的集合CopyOnWriteArraySet ，CopyOnWriteArrayList，ConcurrentLinkedQueue、ConcurrentLinkedDeque，ConcurrentHashMap。

3>集合工具

Collections类方法：

支持Collection的方法：

最大最小	static Object max(Collection coll) static Object max(Collection coll, Comparator comp) static Object min(ColIection coll) static Object min(Collection coll, Comparator comp)
查元素在集合中的数量	static int frequency(Collection c, object o)

支持List的方法：

排序	static void sort(List list) static void sort(List Iist, Comparator c)
反序	static void reverse(List list)
乱序	static void shuffle(List list)
交换指定位置的元素	static void swap(List list, int i, int j)
二分查找，需要有序状态	static int binarySearch(List list, Object key)
填充	static void fill(List Iist, Object obj)
子List查找	static int indexOfSubList(List source, List target)
替换	static boolean replaceAll(List Iist, Object oldVal, Object newVal)

使用Collections排序方法的集合，集合内的元素类要实现Comparable接口，或者排序时提供Comparator。

同步方法：

将集合类添加同步特性

static <T> Collection<T> synchronizedCollection(Collection<T> c)  static <T> List<T> synchronizedList(List<T> list)  static <T> Set<T> synchronizedSet(Set<T> s)  static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)   static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)  static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

4>集合遍历

1>Map遍历

//利用keyset
public static void workByKeySet(Map<String, String> map) {
        Set<String> key = map.keySet();
        for (Iterator it = key.iterator(); it.hasNext();) {
            String key = (String) it.next();
            String value = map.get(key);
        }
}
//利用entrySet
public static void workByEntry(Map<String, String> map) {
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Iterator<Map.Entry<String, String>> it = set.iterator(); it.hasNext();) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) it.next();
            String key = entry.getKey(); entry.getValue());
        }
    }
}

5>技巧

ConcurrentMap.putIfAbsent(key, value) 等同于

if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);