[ JavaSE ]集合类

Java类集（放对象）：  

      类集实际上就属于动态对象数组，在实际开发之中，数组的使用出现的几率并不高，因为数组本身有一个最大的缺

陷:数组长度是固定的。由于此问题的存在，从JDK1.2开始，Java为了解决这种数组长度问题，提供了动态的对象数
组实现框架--Java类集框架。Java集合类框架实际上就是java针对于数据结构的一种实现。而在数据结构之中，最

为基础的就是链表。

HashMap如何设置初始容量：

有以下业务场景：需要查询数据库，分页每次最多查50条。数据库记录为1000条，对每次查询到的结果使用Map<id，Object>进行映射。当使用 new HashMap(50)时，和new HashMap<>(64)是一样的。具体可以看resize函数，会找最近的一个2的n次方的值。如果使用new HashMap(65), 和new HashMap<>(128)效果是一样的。我们知道hashMap的默认装载因子为0.75，当使用new HashMap<>(64)时。最多可以放入64 * 0.75 = 48个元素，在放入第49个元素时，hashMap就会自动扩容为128。这样是非常浪费空间和时间的，所以我们可以设置分页大小为48，然后设置HashMap的默认大小为64，这样就不会自动扩容。

类集结构：

常用集合类的使用：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;

import org.junit.Test;

public class Collection {
	public void TestList() {
		// 实现方式，动态数组
		List<String> arrayList = new ArrayList<>();
		arrayList.add("arrayList");
		arrayList.add(null);
		arrayList.add(null);
		System.out.println(arrayList);
		System.out.println(arrayList.get(1));
		
		// 实现方式，双向链表
		List<String> linkedList = new LinkedList<>();
		linkedList.add("linkedList");
		linkedList.add(null);
		linkedList.add(null);
		System.out.println(linkedList);
		
		// 实现方式，动态数组
		List<String> vector = new Vector<>();
		vector.add("vector");
		vector.add(null);
		vector.add(null);
		System.out.println(vector);
	}
	
	// set的底层实现是没有value的Map
	// 后加入的会覆盖先加入的,必须覆写equals和HashCode方法。
	public void testSet() {
		// Hashset无序存储
		Set<String> set = new HashSet<>();
		set.add("set");
		set.add(null);
		set.add(null);
		set.add("set");
		System.out.println(set);
		
		// TreeSet有序存储,要使用TreeSet,
		// 类必须实现 Comparable接口，且覆写compareTo方法。
		// 因为默认会进行排序，所有属性必须全部进行比较，
		Set<String> set1 = new TreeSet<>();
		set1.add("set");
		// set1.add(null); // TreeSet不能放入空元素
		set1.add("set");
		System.out.println(set1);
	}
	
	// 集合遍历， 不要在遍历集合的时候修改。避免在一个hasNext循环中使用两次next(); 一次跳两个元素
	public void TestCollectionOutput() {
		// 实现方式，动态数组
		List<String> arrayList = new ArrayList<>();
		arrayList.add("arrayList");
		arrayList.add("1");
		arrayList.add("2");
		
		// 迭代输出Iterator(常用)
		Iterator<String> iterator = arrayList.iterator();
		while(iterator.hasNext()) {
			String str = iterator.next();
			System.out.println(str);
			if("1".equals(str)) {
				iterator.remove();
			}
		}
		
		// foreach
		for (String string : arrayList) {
			System.out.println(string);
		}
		
		// ListIterator双向迭代，用法和单向迭代一样，就是能来回迭代。
		
		// Enumetation专用于遍历Vector，他的hasMoreElements() == hasNext() 
		// nextElement() == next();
		
	}
	
	// 底层实现，数组加链表，装载因子0.75，扩容倍数1.75，初始容量16个
	// 1.8的底层实现为数组加红黑树，为了改善一个桶中数据过多的情况。
	@Test
	public void TestMap() {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "Tom");
		map.put(1, "James");
		map.put(2, "James");
		System.out.println(map);
	}
}