Map，Collections和Arrays工具类

今日内容：Map，Collections和Arrays工具类

---

Map

Map中的put方法：
put方法可以将一组对象保存到Map中，返回当前key对应的原始value值。如果key是第一次出现返回的就是null，如果不是这个key已经存在于Map中，再次保存这个key-value时就会修改value值，返回的是原来的value值。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

//统计字符串中每个字符出现的次数
public class inteface {
	public static void main(String[] args) {
		String str="asdgasdf,zhe shi yi ge ceshizifuchuan！";
		times(str);
	}
	public static void times(String str){
		HashMap<Character, Integer> map=new HashMap<>();
		for (int i = 0; i < str.length(); i++) {
			Character c=str.charAt(i);
			if (map.containsKey(c)) {
				int time=map.get(c);//获取重复的键出现的次数，在此基础上++然后写进map就完成了更新value值的操作
				time++;//每重复一次就自增1
				map.put(c, time);
			}else
				map.put(c, 1);
		}
		//遍历一下吧
		Set<Entry<Character,Integer>> set=map.entrySet();
		Iterator<Entry<Character,Integer>> it=set.iterator();
		while (it.hasNext()) {
			Entry<Character,Integer> entry=it.next();
			Character key=entry.getKey();
			Integer value=entry.getValue();
			System.out.println(key+"..."+value);
			
		}
	}
}

HashMap：key采用哈希表算法，保证元素唯一，hashcode和equals方法。
TreeMap：key采用的是二叉树算法，保证元素唯一且按照自然顺序排序。
LinkedHashMap：key采用链表算法，保证元素唯一且保证存入取出顺序一致。

HashMap和HashTable的区别：
HashMap允许null作为键和值，是线程不安全对象，
HashCode不允许null作为键和值，是线程安全的对象。

HashMap中keySet和entrySet方法遍历的注意事项：
keySet： 返回值是一个Set集合。获取key的set集合，遍历key，然后根据HashMap中的get(key)方法获得对应的value值。
entrySet： 返回值是一个类型为Map.Entry<>的Set集合。该方法获得是key-value的关系。使用Map.Entry中的getKey和getValue方法取出对应的key和value值。
注意：HashMap中的values方法可以获得value值，返回类型为Collection，但是不能根据values值获得key的值，因为key的值是唯一的，但是value的值并不是唯一的。

案例一：输入一个字符串，判断每个字符出现的次数：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo5 {
	public static void main(String[] args) {
		String s = "asdfjljlsdfuowejlasjdfugsaljd";
		HashMap<Character, Integer> map = new HashMap<>();//这个集合只是拿来存结果的
		for (int i = 0; i < s.length(); i++) {
			Character key = s.charAt(i);
			if (map.containsKey(key)) {
				Integer value=map.get(key);
				value++;
				map.put(key, value);//每次循环新的value就会把旧的value给顶出去
			}else
				map.put(key, 1);
		}
		//遍历
		Set<Map.Entry<Character, Integer>> set=map.entrySet();
		for(Map.Entry<Character, Integer> met:set){
			Integer value=met.getValue();
			Character key=met.getKey();
			System.out.println(key+"..."+value);
		}
	}
}

JDK5.0的特性：
静态导入：
导入静态成员（方法，变量），为了简化代码。
import static 包名.类名.静态成员名;
导入静态成员之后，书写可以简化，比如导入了system.out之后，输出语句可以由System.out.println();简化成：out.println();,导入java.lang.Math之后，Math.abs()可以省略Math.直接写成abs();，缺点是阅读性变差了。

import static java.lang.System.out;
import static java.lang.Math.*;
import static java.util.Arrays.sort;

public class Demo7 {
	public static void main(String[] args) {
//		out.println("hello");//System.out.println("hello");
//		out.print("java");
//		double f = abs(1.23);//Math.abs(1.23);
//		long num = round(4.56);
//		sort(new int[]{1,2,3,4});//Arrays.sort(new int[]{1,2,3,4});
		
//		method(1,2,3,4,5);
//		method(11,22,33);
		method("",11,123,14,12);
	}

可变参数：
格式：数据类型… 变量名，实质是一个数组，可以按照数组的操作方式来用。
注意：如果参数列表有多个，可变参数一定要写在最后，因为写在前面，后面的参数永远得不到赋值，所有的值都被可变参数给接收了。

	public  static void  method(String b,int... a){	//可变参数
		System.out.println(a);
		System.out.println(a.length);//长度是数组的特性
		for(int num :a){		//遍历
			System.out.println( num);
		}
		System.out.println(a);
	}

Collections

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.TreeSet;

public class Demo8 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		Collections.addAll(list, "2aa","1bbbb","5ccc","4dddddd"); //向集合中添加多个数据，可变参数
		
//		Collections.shuffle(list);//随机打乱list集合中的数据
//		Collections.sort(list); //将list集合按照自然顺序进行排序
//		Collections.sort(list, new Comparator<String>() {	//匿名内部类
//
//			@Override
//			public int compare(String s1, String s2) {
//				return s1.length() -s2.length();
//			}
//		}); //将list集合按照比较器的方式进行排序
//		Collections.reverse(list); //反转list
		//Collections.reverseOrder()返回一个比较器，逆转了原来的顺序，此时的比较器是默认顺序的比较器
//		TreeSet<String> set = new TreeSet<>(Collections.reverseOrder());//，此处是TreeSet的第二种构造方法，传入比较器

		//返回一个比较器，逆转了指定的比较器
		TreeSet<String> set = new TreeSet<>(Collections.reverseOrder(
				new Comparator<String>() {
				
					@Override
					public int compare(String s1, String s2) {
						return s1.length() - s2.length();
					}	
		}));	//逆转了传入的比较器
		set.add("aaa");
		set.add("cc");
		set.add("bbbb");
		set.add("mmmmmm");
		System.out.println(set);
		
//		System.out.println(list);
		
//		Collections.synchronizedList(list);//得到一个线程安全的list
	
	}
}

数组转换成集合可以用Arrays.asList()方法，注意list是固定长度,不能使用集合中的增删方法！！！要使用的话在new一个ArrayList对象就可以操作这个新的对象了

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo9 {
	public static void main(String[] args) {
		/*ArrayList<String> list = new ArrayList<>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		
		Object[] obj = list.toArray(); //将集合转为数组，默认的是Object类型的！！
		for(Object o : obj)
			System.out.println(o);*/
		
	/*	String[]  arr = {"a","b","c"};
	//List<String> list = Arrays.asList("a","b","c");//可以直接写参数，因为这里是可变参数的
		List<String> list = Arrays.asList(arr); //将数组转为集合，注意list是固定长度,不能使用集合中的增删方法！！！
//		list.add("d");//不支持增删操作
//		list.remove("a");//不支持增删操作
*/		
		Integer[] arr = {new Integer(1),2,3,4};
		int[] arr1 = {1,2,3,4};
		
		List<Integer> l1 = Arrays.asList(arr);
		System.out.println(l1);//打印出数据本身，arr里面每个元素都是一个对象，转化成集合后，存储的都是地址值，但是toString被重写了，所以显示出数字
//		Integer in = new Integer(5);
//		System.out.println(in.toString());

		List<int[]> l2 = Arrays.asList(arr1);//注意数据类型是int[]
		System.out.println(l2);//打印地址值，因为此时arr1整体是一个对象，转化成集合后还是一个整体，他的toString没有被改写，打印出地址值。
		
	}
}

案例二：模拟实现扑克牌发牌过程

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;

//模拟实现斗地主，54张牌，2个王，三个人玩，地主20张，农民每人17张，
public class Demo6 {
	public static void main(String[] args) {
		String[] color = { "红桃", "黑桃", "方块", "梅花" };// key
		String[] number = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };// value
		ArrayList<String> list = new ArrayList<>();
		for (int i = 0; i < color.length; i++) {
			for (int j = 0; j < number.length; j++) {
				list.add(color[i] + number[j]);
			}
		}
		list.add("大王");
		list.add("小王");
		Collections.shuffle(list);//洗牌
		ArrayList<String> dizhu = new ArrayList<>();
		ArrayList<String> farmer1 = new ArrayList<>();
		ArrayList<String> farmer2 = new ArrayList<>();
		dizhu.add(list.remove(0));//先给地主发三张，用remove方法，发一张少一张，符合要求
		dizhu.add(list.remove(0));
		dizhu.add(list.remove(0));
		for (int i = 0; i < 17; i++) {
			dizhu.add(list.remove(0));
			farmer1.add(list.remove(0));
			farmer2.add(list.remove(0));
		}
		System.out.println(dizhu);
		System.out.println(farmer1);
		System.out.println(farmer2);
	}
}