java容器

1.为什么使用容器？

    Java在保存数据时，如果是基本类型，且保存数据的数量(大小)确定，那么数组无疑是最好的选择；

    但是，如果保存的数据是对象或者其大小在使用之前无法准确定义，那么如何解决这样的问题呢？

    此时可以考虑使用容器；

2.容器及其特点

    容器：一类保存数据(对象)的数据结构，可以实现基本的存储、检索等操作；

    特点：a.用于存储对象；b.容器的长度可变；c.容器中不可存储基本的数据类型；

3.容器的结构

    主要分为两类，Collection与Map

其中,i表示接口,c表示实现类；

    接口：表示一系列方法的集合，其允许实现类赋予其不同的功能，从而达到“多态”。在面向对象编程语言中，接口通常用来形成规范。

    实现类：集合接口的具体实现(详细描述)，是重用性很高的数据结构。

List:有序的，可伸缩数组，顺序保存对象，可以重复；

    ArrayList:数据存储是连续的，类似于存储对象的数组，等价于”数组的升级”；索引查询较快，插入比较慢，线程不安全；

    LinkedList:双向列表，等介于”链表”，索引较慢，插入比较快，非线程安全；

    Vector:类似于ArrayList，不同点在于线程安全；

    Stack：继承自Vector，实现一个后进先出的堆栈；

Set：不包含重复的元素

    HashSet：数据无序，线程不安全；

    TreeSet(继承自SortedSet)：数据有序；

    LinkedHashSet：根据元素的hashcode决定元素的存储位置，维护元素的次序；

Queue：模拟队列的数据结构，不允许随机访问队列元素；

    PriorityQueue：保存数据按照元素的排序结果，而不是根据加入队列的顺序；

    Deque：代表双端队列，可以当做栈来用；

Map：从键映射到值的数据结构，其中保存的值可以重复，键不能重复；

    HashMap：不允许空的键值对出现，非线程安全

    Hashtable：允许有空的键值对出现，线程安全

小结：

4.基本使用

    4.1 ArrayList存储，排序

public static ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
		//0.输入异常的处理
		ArrayList<Integer> result = new ArrayList<>();
		if(input==null || k>input.length) return result;
		ArrayList<Integer> list = new ArrayList<>();
		//1.使用Arraylist存储值；
		for (int i = 0; i < input.length; i++) {
			list.add(input[i]);
		}
		//2.调用Collections中的静态方法实现排序
		Collections.sort(list);
		//3.选择前k个存入arraylist并返回
		int num = 1;
		for (Integer integer : list) {
			if(num<=k){
				result.add(integer);
				num ++;
			}else{
				break;
			}
		}
		return result;
        
    }
	//输入：num [] = {4,5,1,6,2,7,3,8};,k = 4
	//输出：1,2,3,4

    4.2 HashMap三种遍历方法

Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("Five", 5);
        map.put("Seven", 7);
        map.put("Eight", 8);
        map.put("One",1);
        map.put("Two",2);
        map.put("Three", 3);
        //方法1:遍历输出Value
        System.out.println("依次输出值:");
        Collection<Integer> c = map.values();
        Iterator<Integer> iter = c.iterator();
        while (iter.hasNext()) {
			System.out.println(iter.next());
		}
        //方法2:遍历输出Key
        Set<String> keys = map.keySet();
        Iterator<String> iter1 = keys.iterator();
        while (iter1.hasNext()) {
        	String str = iter1.next();
			System.out.print(str+","+map.get(str));
		}
        System.out.println();
        //方法3:遍历输出Key-Value
        Iterator<Entry<String, Integer>> iter2 = map.entrySet().iterator();
        while (iter2.hasNext()) {
        	Map.Entry<String, Integer> entry = iter2.next();
			System.out.println(entry.getKey()+","+entry.getValue());
		}
	//方法1：8,5,1,7,2,3,
	//方法2：Eight,8Five,5One,1Seven,7Two,2Three,3
	//方法3：Eight,8  Five,5  One,1  Seven,7  Two,2  Three,3 

    4.3 HashMap根据值对键值排序

    import java.util.ArrayList;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	/**
	 * HashMap排序
	 *
	 */
	public class MapTest {
		public static void main(String[] args){
			Map<String, Integer> map = new HashMap<String, Integer>();
			//Map.Entry是Map中声明的一个内部接口，接口为泛型，定义为Entry<K,V>
			//相当于在list中存储的是Map类型的对象
			List<Map.Entry<String, Integer>> list = new ArrayList<>();
			map.put("Five", 5);
			map.put("Seven", 7);
			map.put("Eight", 8);
			map.put("One",1);
			map.put("Two",2);
			map.put("Three", 3);
			//将键值对存入list中
			for(Map.Entry<String, Integer> entry : map.entrySet()){
				 list.add(entry); 
			}
			//调用list.sort()方法排序,递增排序
			list.sort(new Comparator<Map.Entry<String, Integer>>(){
				//重写比较的方法，实现排序
				  @Override
				   public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
						return o1.getValue()-o2.getValue();} 
			}); 
			
			for(Map.Entry<String, Integer> entry: list){
				  System.out.println(entry);
			}
		}
	}
	//输出：One=1,Two=2,Three=3,Five=5,Seven=7,Eight=8,

5.区分点：

    5.1 Collection与Collections

        其中Collection是容器层次结构中的根接口，JDK不提供其具体实现，仅仅提供更加具体的子接口实现；

        而Collections是一个提供一些处理容器类静态方法的类；(类似于Arrays）

参考：

• https://www.cnblogs.com/nayitian/p/3266090.html
• https://www.cnblogs.com/goody9807/p/6441114.html