package cn.Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Set;

public class MapDemo 
{
	public static void main(String[]__)
	{
		//identityHashMap只有当key是引用的同一个对象的时候，才不会put进去这个Entry组,也就是放宽了这个插入的条件
		IdentityHashMap<String, Integer> map=new IdentityHashMap<>();
		map.put(new String("hhh"),123);
		map.put(new String("hhh"),123);
		map.put("wangwei",123);
		map.put("wangwei",123);
		System.out.println(map);
		//EnumMap在内部使用数组进行保存，所以非常高效,与enumset不同的是，EnumMap中不是使用静态方法来获得一个对象的
		
		EnumMap<Season, Integer> EM=new EnumMap<>(Season.class);
		
		//Map集合的速度：HashMap和Hashtable差不多，但是HashMap还是略胜一筹，TreeMap有的好处就是有序
		
		
		/*
		 * HashSet和HashMap都是使用散列做法来加快查询的速度，在这两个容器的底层，都有一个所谓桶的结构
		 * 桶：通常情况下，一个桶内只能存储一个元素，但是当Hash值重复了之后，而equals判断又不为相等，则这个时候，就会形成链表去维护这个桶内的多个元素
		 * 容量（capacity）：hash表中桶的数量
		 * 尺寸(size)：记录当前结构中的元素
		 * 负载因子：szie/capacity得到一个目前桶内被填充的容量
		 * 
		 * 
		 * */
		
		//对collections工具类的探查：
		//1.排序操作
		/*
		 * 翻转list集合中元素的顺序：static void reverse(List) ps:list类也就有ArrayList,LinkedList,Vector这三种了
		 * 对于list集合中随机洗牌:static void shuffle(List)
		 * static void sort(List) ps:这里按照的顺序应该是根据compareTo比较得到的？
		 * static void sort(List,comparator)
		 * 
		 * */
		//翻转方法
		List<Integer> lt=new ArrayList<>();
		lt.add(1);
		lt.add(2);
		lt.add(3);
		System.out.println("before: "+lt);
		Collections.reverse(lt);
		System.out.println(" and after: "+lt);
		//随机洗牌
		lt.add(6);
		lt.add(4);
		lt.add(5);
		Collections.shuffle(lt);
		System.out.println(" shuffle : "+lt);//这里这个完全可以用到迷宫那里随机选择数组元素那里，当时还笨笨的用的什么Math.random
		//排序
		List<A> ltA=new ArrayList<>();
		ltA.add(new A(1));
		ltA.add(new A(3));
		ltA.add(new A(2));
		
		System.out.println(ltA);
		//这里无法调用因为排序是需要实现comparable类
		Collections.sort(ltA);
		Comparator<A> cmp=(A a,A b)->
		{
			return a.value-b.value;
		};
		Collections.sort(ltA,cmp);
		System.out.println(ltA);
	}
	
	//同步控制
	List<Integer> list=Collections.synchronizedList(new ArrayList<>());
	Set<Integer>set=Collections.synchronizedSet(new HashSet());
			
}
//定义两个工具类
class A
{
	public Integer value;
	A(Integer a){value=a;}
	@Override
	public String toString() {
		return value+"";
	}
	
}
class B implements Comparable<Integer>
{
	public Integer value;
	B(Integer a){value=a;}
	@Override
	public int compareTo(Integer o) {
		
		return value-o;
	}
	public String toString() {
		return value+"";
	}
}