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> 是一种以键的顺序对元素排序的有序集合。