Java 学习笔记——集合

public class CollectionStudy {

@Test
public void testLinkedList() {
List<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
ListIterator<Integer> li = list.listIterator(); //迭代器遍历
while (li.hasNext()) {
int n = li.next();
if (n == 2) {
// ListIterator 对象可以实现在集合遍历时操作集合（添加、删除元素等）
li.add(22);
}
}

for ( int n : list ) { // for each 遍历
System.out.println(n +" ");
}

// list.add(4);
// li.next(); //迭代器发现集合结构被自身修改，抛 ConcurrentModificationException

// 可以将多个迭代器附加给一个链表
ListIterator<Integer> li2 = list.listIterator();
li2.next();
// li.next(); //迭代器发现集合结构被另一个迭代器修改，抛 ConcurrentModificationExcpetion

// 但是每个迭代器的 set() 方法同时修改集合元素的值，是可以的。
li.set(0);
li2.set(10);

Collections.sort(list);
System.out.println(list);
}

@Test
public void testArrayList() {
List<String> list = new ArrayList<>();
list.add("gone");
list.add("with");
list.add("the");
list.add("wind");
Collections.sort(list);
System.out.println(list);
}

@Test
public void testHashSet() {
// 元素不重复、以随机的顺序被访问
Set<String> set = new HashSet<>();
set.add("I");
set.add("am");
set.add("coming");
set.add("hello");
set.add("world");
System.out.println(set);
}

@Test
public void testTreeSet() {
// 元素不重复，并将元素排序后遍历出
// 每添加一个元素，都会被放在排好序正确的位置
Set<String> set = new TreeSet<>();
set.add("am");
set.add("I");
set.add("world");
set.add("hello");
set.add("coming");
System.out.println(set);
}

@Test
public void testPriorityQueue() {
PriorityQueue<GregorianCalendar> pq = new PriorityQueue<>();
pq.add(new GregorianCalendar(2004, Calendar.JUNE, 22));
pq.add(new GregorianCalendar(2008, Calendar.DECEMBER, 9));
pq.add(new GregorianCalendar(2002, Calendar.DECEMBER, 10));
pq.add(new GregorianCalendar(2005, Calendar.DECEMBER, 3));

System.out.println("Iteratiing over elements...");
for (GregorianCalendar date : pq) {
System.out.println(date.get(Calendar.YEAR));
}

System.out.println("Removing elements...");
// 遍历时将最小的元素移动到根，remove()总是移除优先级队列中最小的元素
while (!pq.isEmpty()) {
System.out.println(pq.remove().get(Calendar.YEAR));
}
}

@Test
public void testHashMap() {
Map<Integer, String> map = new HashMap<>();
map.put(0, "A");
String s = map.put(0, "a"); // put() 返回上次存放的值
System.out.println(s);
map.put(1, "b");
map.put(2, "c");

System.out.println("keySet :");
Set<Integer> keys = map.keySet();
System.out.println(keys);

System.out.println("\nvalues :");
System.out.println(map.values());

System.out.println("\nremove :");
for (int n : keys) {
if (n == 2) {
System.out.println("removed key " + n);
map.remove(n);
}
}
//迭代器操作
Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
while( it.hasNext() ) {
Map.Entry<Integer, String> e = it.next();
int key = e.getKey();
if ( key == 1) {
System.out.println("removed key " + key + " value " + e.getValue());
it.remove();
}
}

System.out.println("\nkey = value");
for (Map.Entry<Integer, String> e : map.entrySet()) {
int key = e.getKey();
String value = e.getValue();
System.out.println(key + " = " + value);
}
}

}    Java 中的集合有 Collection<E> 和 Map<K,V> 两类基本的接口，Collection<E> 接口继承了 Iterable<E> 接口，所以实现 Collection<E> 接口的集合都可以通过 iterator() 方法返回迭代器遍历集合。Collection<E> 接口下主要有 List<E>、Set<E>、Queue<E> 等子接口。Map<K,V> 接口的主要实现类有 HashMap<K,V> 和 TreeMap<K,V>。

    List<E> 接口的实现类主要有 ArrayList<E> 和 LinkedList<E>，ArrayList<E> 底层由可动态分配空间的数组实现，支持快速随机访问，读取元素效率较高；LinkedList<E> 底层由链表结构实现，插入和删除元素的效率较高，List 集合中的元素可以重复，遍历元素时会按照元素添加的顺序输出。可以通过集合的 listIterator() 方法返回 ListIterator 对象实现对 List 集合更多的操作。

    Set<E> 集合接口的实现类主要有 TreeSet<E> 和 HashSet<E>，TreeSet<E> 集合中的元素是已排好序存放的，每添加一个元素都会被放在正确的位置上，遍历集合时元素按照排好序的顺序输出；HashSet<E> 是一个基于 HashMap 实现的无序的集合，可以快速访问元素，Set 集合中的元素都是不可重复的。

    Queue<E> 接口的实现类主要是 PriorityQueue<E>，它是一个基于优先级的队列，它的 remove()、element()、poll()、peek() 方法总会处理/返回当前队列中的最小元素。

    HashMap<K,V> 以键值对的形式存放元素，其中键是唯一的，通过 map.entrySet().iterator() 方法返回 Map 集合的迭代器；TreeMap<K,V> 是一种以键的顺序对元素排序的有序集合。