[Java] Java中的容器

Java中容器可分为两种：

• Collection：一个独立元素的序列；
• Map：一组成对的"键值对"对象；

这两大类又根据其他条件衍生了多种子类。整个容器类结构图如下，绿色为常用容器:

1.Collection

Collection是单列集合的顶层接口，Collection中又根据是否有序、能否重复存储元素分为两类：

• 1.List:有序列表，可存储重复元素；
• 2.Set：无须列表，不可存储重复元素；

1.1.List

public interface List<E> extends Collection<E>

List是有序Collection，可以重复存储元素。

1.1.1.ArrayList

public class ArrayList<E>
    extends AbstractList<E> 
    implements List<E>, RandomAccess, Cloneable, Serializable

常用api

1. boolean add(E e)

将指定的元素添加到此列表的尾部。

2. void add(int index, E element)

将指定的元素插入此列表中的指定位置。

3. boolean addAll(Collection<? extends E> c)

按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。

4. boolean addAll(int index, Collection<? extends E> c)

从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

5. void clear()

移除此列表中的所有元素。

6. Iterator iterator()

返回按适当顺序在列表的元素上进行迭代的迭代器。

7. boolean contains(Object o)

如果此列表中包含指定的元素，则返回 true。

8. E get(int index)

返回此列表中指定位置上的元素。

9. int indexOf(Object o)

返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。

10. boolean isEmpty()

如果此列表中没有元素，则返回 true

11. int lastIndexOf(Object o)

返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。

12. E remove(int index)

移除此列表中指定位置上的元素。

13. boolean remove(Object o)

移除此列表中首次出现的指定元素（如果存在）。

14. E set(int index, E element)

用指定的元素替代此列表中指定位置上的元素。

15. int size()

返回此列表中的元素数。

16. Object[] toArray()

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

17. T[] toArray(T[] a)

按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

18. ListIterator listIterator()

返回此列表元素的列表迭代器（按适当顺序）。

19. ListIterator listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

1.1.2.LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

底层采用链表实现，因此查询慢，修改快。

常用api

ArrayList中的API，LinkedList中同样提供了，因此，以下是LinkedList中特有的API。

1. void addFirst(E e)

将指定元素插入此列表的开头。

2. void addLast(E e)

将指定元素添加到此列表的结尾。

3. E element()

获取但不移除此列表的头（第一个元素）。

4. E getFirst()

返回此列表的第一个元素。

5. E getLast()

返回此列表的最后一个元素。

6. boolean offer(E e)

将指定元素添加到此列表的末尾(最后一个元素)

7. boolean offerFirst(E e)

在此列表的开头插入指定的元素。

8. boolean offerLast(E e)

在此列表末尾插入指定的元素。

9. E peek()

获取但不移除此列表的头（第一个元素）。

10. E peekFirst()

获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

11. E peekLast()

获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

12. E poll()

获取并移除此列表的头（第一个元素）,如果此列表为空，则返回 null。

13. E pollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

14. E pollLast()

获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

15. E pop()

从此列表所表示的堆栈处弹出一个元素。

16. void push(E e)

将元素推入此列表所表示的堆栈。

17. E removeFirst()

移除并返回此列表的第一个元素。

18. E removeLast()

移除并返回此列表的最后一个元素。

1.2.Set

public interface Set<E> extends Collection<E>

Set是无序Collection，不能重复存储元素。没有索引值，不可存储重复元素，不可以根据索引值获取元素

1.2.1.HashSet

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{

底层采用哈希算法生成哈希值绝对在容器中的存储位置,如果两个对象的哈希值不同，则直接存储即可，但如果两个对象的哈希值相同，则通过对象的equals()进行判断两个对象的内容是否相同，如果equals()方法返回true,则视为重复元素，存储失败;如果equals()返回false,则发生散列冲突，可以采用拉链法或者垃圾桶法解决散列冲突,即将当前元素挂到发生冲突的元素的下面.存储HashSet中的元素不保证存入的顺序和取出的顺序一致.

常用API

1. boolean add(E e)

如果此set中尚未包含指定元素,则添加指定元素。

2.boolean addAll(Collection<? extends E> c)

如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。

2. void clear()

从此 set 中移除所有元素。

3. boolean contains(Object o)

如果此 set 包含指定元素，则返回 true。

4. boolean isEmpty()

如果此 set 不包含任何元素，则返回 true。

5. Iterator iterator()

返回对此 set 中元素进行迭代的迭代器。

6. boolean remove(Object o)

如果指定元素存在于此 set 中，则将其移除。

7. int size()

返回此 set 中的元素的数量（set 的容量）。

8. Object[] toArray()

返回一个包含 set 中所有元素的数组。

9. T[] toArray(T[] a)

返回一个包含此set中所有元素的数组；返回数组的运行时类型是指定数组的类型。

1.2.2.LinkedHashSet

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, Serializable

相比HashSet而言，LinkedHashSet通过链表保证存入的顺序和取出的顺序一致。

1.2.3.SortedSet

public interface SortedSet<E> extends Set<E> 

具有排序功能的接口。

常用API

Comparator<? super E> comparator()

返回对此set中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。

E first()

返回此 set 中当前第一个（最低）元素。

SortedSet headSet(E toElement)

返回此 set 的部分视图，其元素严格小于 toElement。

E last()

返回此 set 中当前最后一个（最高）元素。

SortedSet subSet(E fromElement, E toElement)

返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。

SortedSet tailSet(E fromElement)

返回此 set 的部分视图，其元素大于等于 fromElement。

1.2.4.TreeSet

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable

SortedSet的一个实现类，底层采用二叉树进行存储元素，添加到这个容器中的元素会自动按照自然顺序(由小到大)进行排序。

2.Map

public interface Map<K,V>

Map是双列集合的顶层接口，以键值对的形式存储元素，允许使用键来查找值。

2.1.HashMap

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

基于哈希表的 Map 接口的实现。允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

常用API

1. void clear()

从此映射中移除所有映射关系。

2. Object clone()

返回此 HashMap 实例的浅表副本：并不复制键和值本身。

3. boolean containsKey(Object key)

如果此映射包含对于指定键的映射关系，则返回 true。

4. boolean containsValue(Object value)

如果此映射将一个或多个键映射到指定值，则返回 true。

5. Set<Map.Entry<K,V>> entrySet()

返回此映射所包含的映射关系的 Set 视图。

6. V get(Object key)

返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。

7. boolean isEmpty()

如果此映射不包含键-值映射关系，则返回 true。

8. Set keySet()

返回此映射中所包含的键的 Set 视图。

9. V put(K key, V value)

在此映射中关联指定值与指定键。

10. void putAll(Map<? extends K,? extends V> m)

将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。

11. V remove(Object key)

从此映射中移除指定键的映射关系（如果存在）。

12. int size()

返回此映射中的键-值映射关系数。

13. Collection values()

返回此映射所包含的值的 Collection 视图。

2.2.LinkedHashMap

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>

通过相比其父类HashMap而言，它可以保证插入顺序。

2.3.TreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, Serializable

底层采用红黑树对其键进行自然顺序排序，或者根据创建映射时提供的Comparator进行排序。

3.Iterator遍历序列

Java的Iterator迭代器提供了对容器的访问。Collection接口的iterator()方法会返回一个Iterator对象，Iterator将准备好返回序列的第一个元素。

• 使用hasNext()方法检查序列中是否还有元素；
• 使用next()方法获得序列中的下一个元素；
• 使用remove()方法将返回的元素移除。

Iterator只能单向移动，如下示例：

		Iterator<String> iterator = list.iterator();
		while(iterator.hasNext()){
			str = iterator.next();
		}

ListIterator双向遍历

ListIterator支持双向移动，不过只支持List接口及其子类。

• 使用hasPrevious()方法检查序列中是否还有前一个元素；
• 使用hasNext()方法检查序列中是否还有元素；
• 使用next()方法获得序列中的下一个元素；
• 使用previous()方法获得序列中的下一个元素；

如下示例：

ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()){
	str = listIterator.next();
	System.out.println(str);
}

while(listIterator.hasPrevious()){
	str = listIterator.previous();
	System.out.println(str);
}

4.Foreach与迭代器

foreach语句可应用到Collection上，对Collection中的元素进行遍历:

public class ForeachTest {

	public static void main(String[] args) {

		List<String> list = new ArrayList<String>();
		list.add("kobe");
		list.add("james");
		list.add("wade");
		
		for(String str: list){
			System.out.println(str);
		}
	}
}

而Collection对象之所以能够用于foreach语句中，是因为Collection实现了Iterable接口，实现Iterable接口将允许对象成为 “foreach” 语句的目标。因此，只要任意类实现该接口，都可以用于foreach中，如：

public class IteratorClass implements Iterable<String> {


	protected String[] words = "And that is how we know the Earth to be banana-shaped.".split(" ");
	
	public Iterator<String> iterator(){
		
		return new Iterator<String>(){
			private int index = 0;

			@Override
			public void forEachRemaining(Consumer<? super String> arg0) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public boolean hasNext() {
				return index < words.length;
			}

			@Override
			public String next() {
				return words[index++];
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}
			
		};
	}
	public static void main(String[] args){
		IteratorClass itc = new IteratorClass();
		for(String s: itc){
			System.out.println(s);
		}
	}
}

5.Map的遍历

由于Map中没有向Collection中提供的iterator()方法，也没有实现Iterable接口，因此不能像遍历Collection那样遍历Map。Map提供了一个entrySet()方法用来得到映射中包含映射关系的Set<Map.Entry<K,V>>视图，可以使用foreach对该Set视图进行遍历，从而遍历整个Map中的键值。

Set<Entry<Integer, String>> sset = map.entrySet();
for(Map.Entry<Integer, String> en:sset){
	int key = en.getKey();
	String value = en.getValue();
}

除这种方式外，也可以利用Map的keySet()方法和values()方法，对键值进行单独遍历。