Java容器类总结

package test2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.TreeMap;
import java.util.TreeSet;

public class Test {
	public static void main(String[] args) {
		Collection<Integer> collection=new ArrayList<Integer>(Arrays.asList(2,3,4,5));
		//泛型也支持向上转型，传递子类
		Integer[] is=new Integer[]{6,7,8,9,0};
		collection.addAll(Arrays.asList(is));
		Collections.addAll(collection, 1,2,3,4);
		Collections.addAll(collection, is);
		System.out.println(collection);
		System.out.println();
		//显式类型参数声明
		List<Integer> list=Arrays.<Integer>asList(1,2,3,5);
		//为什么这里在输入一个就报错？了解底层实现才能解释
		//list.add(2);
		System.out.println(list);
		System.out.println("------------------------------");
		System.out.println(fill(new ArrayList<String>()));//按照被插入的顺序存储元素
		System.out.println(fill(new LinkedList<String>()));//按照被插入的顺序存储元素，两个list的区别仅在于某些操作效率不同
		System.out.println(fill(new HashSet<String>()));//不允许重复元素，随机存储，为的是最快的获取元素
		System.out.println(fill(new TreeSet<String>()));//不允许重复元素，按照比较结果的升序排列，也就是前面小后面大
		System.out.println(fill(new LinkedHashSet<String>()));//不允许重复元素，按照插入元素存储
		System.out.println(fill(new HashMap<String,String>()));//键值对，键不能重复，存储随机，最快获取
		System.out.println(fill(new TreeMap<String,String>()));//键值对，键不能重复，按照键的升序排列
		System.out.println(fill(new LinkedHashMap<String,String>()));//键值对，键不能重复，按照插入顺序排列，还保留了hash的查询速度
		//Collections和Arrays一样，一个是对容器的各种操作，一个是对数组的各种操作
		//对list进行排序
		Collections.sort(list); 
		//打乱顺序
		Collections.shuffle(list);
		//subList 交集操作
		list.subList(1,3);
		//contains
		list.contains(11);
		//containsAll
		list.containsAll(list);
		//retainAll
		list.retainAll(list);
		//addAll
		list.addAll(list);
		//toArray 类似于字符串转化数组操作
		list.toArray();
		//替换一处元素
		list.set(1, 11);
		list.clear();
		System.out.println(list.isEmpty());;
		//总结，容器类中有大量的方法，熟脸掌握这些方法是提高开发效率的必备。
		//在工具类Collections中，有addAll()、sort()、shuffle()等常用方法
		//在list及其子类中，有add、remove、get、addAll、subList、retainAll、contains、containsAll、toArray等一系列常用方法
		
		//迭代器可以遍历删除元素、迭代器统一了对容器的访问方式
		//ListIterator只能适用于list，可以双向移动，可以修改元素
		//linkedlist有许多同质的方法，为了实现栈、队列、双端队列而增加的接口方法
		//stack
		//set 接口和collection相同，没有其他额外的接口，只是实现了这些接口而已
		//用TreeSet排序是按照字典序，大小写分开，如果不想分开，可以向构造器传入String.CASE_INSENSITIVE_ORDER比较器
		
		//用map统计数据出现次数的最好方法
		Map<Integer,Integer> map=new HashMap<Integer,Integer>();
		int[] array=new int[]{2,3,4,6,2,6,89,5,4,3};
		//不管键存在不存在，直接get，然后用null判断，为null则初始化为1，否则则加一操作
		for(int num:array){
			Integer a=map.get(num);
			map.put(num, a==null?1:a+1);
		}
		System.out.println(map);
		//map其他用法和方法
		map.containsKey(1);//key只能有一个
		map.containsValue(2);//value可以有多个重复，只要key不同就行
		map.keySet();	//返回键的set序列
		map.values();	//返回值的collection
		map.entrySet();	//返回键值对的set序列
		Map.Entry<Integer, Integer> entry=(Entry<Integer, Integer>) map.entrySet();
		entry.getKey();
		entry.getValue();
		//queue 因为linkedlist实现queue的接口，所以可以将linkedlist向上转型来完成queue的操作
		Queue<Integer> queue=new LinkedList<Integer>();
		//只要实现了iterable返回一个iterator对象，就可以使用foreach语法对容器或者自己的实现类进行遍历
	}
	static Collection<String> fill(Collection<String> collection){
		collection.add("rat");
		collection.add("cat");
		collection.add("dog");
		collection.add("dog");
		return collection;
	}
	static Map<String, String> fill(Map<String, String> map){
		map.put("rat", "fuzzy");
		map.put("cat", "rags");
		map.put("dog", "bosco");
		map.put("dog", "spot");
		return map;
	}
}