Java-Collection和Map容器

Collection集合接口

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

主要方法:

boolean add(Object o) —— 添加对象到集合
boolean remove(Object o) —— 删除指定的对象
boolean contains(Object o) —— 查找集合中是否有指定的对象
boolean isEmpty() —— 判断集合是否为空
boolean containsAll(Collection c) —— 查找集合中是否有集合c中的元素
boolean addAll(Collection c) —— 将集合c中所有的元素添加给该集合

int size() —— 返回当前集合中元素的数量

Iterator iterator() —— 返回一个迭代器

void clear() —— 删除集合中所有元素
void removeAll(Collection c) —— 从集合中删除c集合中也有的元素
void retainAll(Collection c) —— 从集合中删除集合c中不包含的元素

List接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置（按照元素插入顺序存储）。用户能够使用get()方法和索引来访问List中的元素。

LinkedList类

LinkedList实现了Deque接口（Deque继承了Queue接口），继承AbstractSequentialList类，允许null元素，底层用双向链表实现，在添加删除方面比较便捷，按照添加顺序存储，没有初始大小。LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意：LinkedList是非同步方法。

ArrayList类

ArrayList实现List接口，继承了AbstractList类，底层用可变大小的数组实现，允许所有元素，包括null，在随机访问元素方面比较便捷，按照添加元素顺序存储，初始大小为10，每次扩容当前大小的1/2。ArrayList可用作动态数组。

注意：ArrayList也是非同步的（unsynchronized），Vector非常类似ArrayList，但是Vector是同步的，而且 初始化大小为 10 ，扩容原来的一倍。对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

public class ArrayListTest {

	public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add(100);
		arrayList.add(12.14);
		arrayList.add(true);
		arrayList.add("arrayList");
		arrayList.add('A');
		System.out.println(arrayList.get(0));
		
		// 获取ArrayList大小用 size();
		for (int i = 0; i < arrayList.size(); i++) {
			System.out.println(arrayList.get(i));
		}
		
		// contains是否包含某个对象
		System.out.println("是否包含\"arrayList\"字符串" + arrayList.contains("arrayList"));
		
		arrayList.add(101);
		// 输出第一次出现下标 0 开始
		System.out.println("101第一次出现位置：" + arrayList.indexOf(101));
		
		// 元素个数
		System.out.println("集合中元素个数：" + arrayList.size());
		
		// 判断集合是否没有元素
		System.out.println("arrayList是否有元素：" + arrayList.isEmpty());
		
		Iterator iterator = arrayList.iterator();
		// 如果迭代器iterator不为空，输出iterator.next()
		while (iterator.hasNext()) {
			System.out.print(iterator.next() + " ");
		}
		
		// contains算法包含某个对象
		System.out.println(arrayList.contains("arrayList"));
		
		// 删除元素，被删除后面元素往前移动
		arrayList.remove(1);
		Iterator it = arrayList.iterator();

		while (it.hasNext()) {
			System.out.print(it.next() + " ");
		}
		
		Object[] objects = arrayList.toArray();
		for (Object object : objects) {
			System.out.print(object + " ");
		}
		System.out.println("数组中大小：" + objects.length);
		
		// 清空ArrayLIst
		arrayList.clear();
		System.out.println("集合中元素个数：" + arrayList.size());
		
	}
}

public class LinkedListDemo {
	
	public static void main(String[] args) {
		News news1 = new News("1001","1001","1001",new Date());
		News news2 = new News("1002","1002","1002",new Date());
		News news3 = new News("1003","1003","1003",new Date());
		News news4 = new News("1004","1004","1004",new Date());
		News news5 = new News("1005","1005","1005",new Date());
	
		LinkedList<News> linkedList = new LinkedList<News>();
	
		linkedList.add(news1);
		linkedList.add(news2);
		linkedList.add(news3);
		linkedList.add(news4);
		linkedList.add(news5);
		
		Iterator<News> iterator = linkedList.iterator();
		
		while (iterator.hasNext()) {
			News news = iterator.next();
			System.out.println(news);
			/*System.out.println(news.getId() + " " + news.getName() + " " 
					+ news.getCreater() + " " + news.getCreateTime());*/
		}
		
		System.out.println("\n-------------------\n");
		
		// 在开始添加
		linkedList.addFirst(news5);
		
		// 在最后添加
		linkedList.addLast(news1);
		
		// 删除1002
		linkedList.remove(2);
		
		// 删除第一个
		linkedList.removeFirst();
		
		// 删除最后一个
		linkedList.removeLast();
		
		for (int i = 0; i < linkedList.size(); i++) {
			System.out.println(linkedList.get(i));
		}
	}
}

Set接口

Set是一种不包含重复的元素的Collection（Set最多有一个null元素），无序存储（HashSet不按照元素插入顺序存储，LinkedHashSet按照元素插入顺序存储，TreeSet按照设定的比较顺序进行排序存储）

HashSet类

不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能有一个null元素，查询速度比较快。

注意：ListHashSet可以按照存入元素顺序存储

TreeSet

不允许出现重复元素，底层用红-黑树结构存储，按照存入对象的判定顺序顺序存储（自定义对象要实现Comparable接口，重写compareTo方法）

TreeSet对元素的排序有两种方式：

方式一：使元素（对象）对应的类实现Comparable接口，覆盖compareTo方法。这样元素自身具有比较功能。

方式二：使TreeSet集合自身具有比较功能，定义一个类实现Comparable接口覆盖其compareTo方法。（相当于自定义了一个比较器）将该类对象作为参数传递给TreeSet集合的构造函数。（TreeSet(Comparator<?
super E> c) ）

public class SetDemo {

	/**
	 * · HashSet存储元素是无序的
	 */
	
	/**
	 * · treeSet存储对象如果想要排序，必须重写Comparable方法
	 */
	
	public static void main(String[] args) {
		
		Set<String> set = new HashSet<String>();
		
		set.add("java");
		set.add("c++");
		set.add("golang");
		set.add("python");
		set.add("c");
		set.add("c"); // 没有重复对象
		
		System.out.println(set);
		
		// 遍历HsahSet
		for (String string : set) {
			System.out.println(string);
		}
		
		Set<Integer>  treeSet = new TreeSet<Integer>();
		
		treeSet.add(50);
		treeSet.add(80);
		treeSet.add(90);
		treeSet.add(90); // 没有重复对象
		treeSet.add(20);
		treeSet.add(100);
		
		System.out.println(treeSet);
		// 利用迭代器遍历TreeSet
		Iterator<Integer> iterator = treeSet.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
		
		Student s1 = new Student("1001", "cr7", 88);
		Student s2 = new Student("1002", "lm10", 78);
		Student s3 = new Student("1003", "c9", 68);
		Student s4 = new Student("1004", "pd19", 98);
		
		Set<Student>  tree = new TreeSet<Student>();
		
		tree.add(s1);
		tree.add(s2);
		tree.add(s3);
		tree.add(s4);
		
		// student对象 需要Comparable接口覆盖其compareTo方法
		Iterator<Student> it = tree.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

Map集合接口

Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

主要方法:

void clear( ) —— 从此映射中移除所有映射关系（可选操作）
void putAll(Map m) —— 从指定映射中将所有映射关系复制到此映射中（可选操作）

boolean containsKey(Object k) —— 如果此映射包含指定键的映射关系，则返回 true
boolean containsValue(Object v) —— 如果此映射将一个或多个键映射到指定值，则返回 true
boolean isEmpty( ) —— 如果此映射未包含键-值映射关系，则返回 true
boolean equals(Object obj) —— 比较指定的对象与此映射是否相等

Set entrySet( ) —— 返回此映射中包含的映射关系的 Set 视图

Object get(Object k) —— 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
Object put(Object k, Object v) —— 将指定的值与此映射中的指定键关联（可选操作）
Object remove(Object k) —— 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）

int hashCode( ) —— 返回此映射的哈希码值
int size( ) —— 返回此映射中的键-值映射关系数

Set keySet( ) —— 返回此映射中包含的键的 Set 视图

Collection values( ) —— 返回此映射中包含的值的 Collection 视图

HashMap类

HashMap是非同步的，并且允许null，即null value和null key，但是只能有一个null Key，因为Key是不能重复的，查询的效率比较高，默认初始容量 (16) 和默认加载因子 (0.75) ，底层是数组+链表实现的，JKD1.8底层是数组+链表+红黑树

注意：LinkedHashMap可以按照存入元素顺序存储。

TreeMap类

TreeMap继承Map接口，排序根据红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

HashMap和Hashtable的区别？

HashMap继承于AbstractMap类，Hashtable继承于Dictionary类
HashMap可以有 null key 和null value，Hashtable不允许有null key 和 null value
HashMap是非线性安全的，Hashtable是线性安全的
HashMap默认的初始化大小为16，之后每次扩充，容量变为原来的2倍；Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。

注：迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者loadfactor过低。

public class MapDemo {
	public static void main(String[] args) {
		
		Student s1 = new Student("1001", "cr7", 88);
		Student s2 = new Student("1002", "lm10", 78);
		Student s3 = new Student("1003", "c9", 68);
		Student s4 = new Student("1004", "pd19", 98);
		
		// 创建HashMap对象，
		Map<String, Student> map = new HashMap<String, Student>();
		
		map.put("s1", s1);
		map.put("s2", s2);
		map.put("s3", s3);
		map.put("s4", s4);
		
		// 获取map中所有的键，存放在一个Set中
		System.out.println(map.keySet());
		
		// 获取map中所有的值，存放在一个集合中
		System.out.println(map.values());
		
		// 键值对
		System.out.println(map);
		
		// foreach遍历
		for (String string : map.keySet()) {
			System.out.println(string + " : " + map.get(string));
		}
		
		System.out.println("\n_____删除______\n");
		
		// 删除
		map.remove("s4");
		
		// 迭代器遍历
		Iterator iterator = map.keySet().iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println(string + " : " + map.get(string));
		}
		
		
		// 是否包含某个键
		System.out.println(map.containsKey("s1"));
		System.out.println(map.containsKey("s4"));
		
		// 是否包含某个值
		System.out.println(map.containsValue(s1));
		System.out.println(map.containsValue(s4));
		
		// 元素个数
		System.out.println(map.size());
		
		// 获取Map实体遍历
		Set<Entry<String, Student>> setEntity = map.entrySet();
		Iterator<Entry<String, Student>>  iterator2 = setEntity.iterator();
		while (iterator2.hasNext()) {
			Entry<String, Student> entry = iterator2.next();
			System.out.println(entry.getKey() + " : " + entry.getValue());
		}
	}
}