集合框架之Map

一、Map特点

1.增删改查

package com.cxy.map;


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


/**
 * map集合的特点
 * 键值对
 * 遍历：拿到key 再拿值
 * 拿到映射关系，键值都有了
 *
 *HashMap与Hashtable的区别
 *1.hashTable 是线程安全的
 *2.jdk1.8以下hashTbale的key不能存放null
 */
public class Demo1 {

	public static void main(String[] args) {
		Hashtable<Object, Object> hashtable = new Hashtable<>();
		 //public synchronized V put(K key, V value) 
		hashtable.put("a", 1);
		
		Map<String,Integer> map = new HashMap<>();
		//V put(K key, V value)
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 3);
		map.put("d", 4);
		System.out.println(map);
		
		
		Object remove = map.remove("b");
		System.out.println(remove);
		System.out.println(map);
		
		//修改 也是调用put方法
		map.put("c", 32);
		System.out.println(map);
		
		//查询
		System.out.println(map.get("c"));
	}
}

二、遍历方式（两种）

①：keySet
将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，再根据get方法。获取每一个键对应的值。
注意：keySet():迭代后只能通过get()取key
②：enteySet
Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。 Map.Entry表示映射关系。
注意：entrySet()：迭代后可以e.getKey()，e.getValue()取key和value。返回的是Entry接口

		//1.先拿到map集合中的所有key
		Set keys = map.keySet();
		for (Object key : keys) {
			System.out.println("键:"+key+"值:"+map.get(key));
		}
		
		
		//2.拿到映射关系
		 Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println("键:"+entry.getKey()+"值:"+entry.getValue());
		}

三、常用实现类HashMap

3.1 案例： 统计字符串各字母出现的次数

3.1.1根据字母进行排序

package com.cxy.map;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Demo2 {
		/**
		 * 实现思路：
		 * 1.做字符串切割,得到一个字符数组
		 * 2.接下来遍历，拿到单个字符
		 * 3.如果该字符没有出现过，即value值为null，那么该字符key，值初始化为1
		 * 4.如果已经出现过，拿到原来的值+1
		 * 
		 */
	public static void main(String[] args) {
		String s = "abcdbbdbjshhjjajjssjjnckeokjd";
		char[] arr = s.toCharArray();
		Map<Character, Integer> map = new TreeMap<>();
		for (char c : arr) {
			Integer value = map.get(c);
			if(value == null) {
				map.put(c, 1);
			}else {
				map.put(c, value+1);
			}
			//System.out.println(c);
			
		}
		
		Set<Entry<Character, Integer>> entrySet = map.entrySet();
		for (Entry<Character, Integer> entry : entrySet) {
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
	}
}

运行结果：

3.1.2 根据次数进行排序

package com.cxy.map;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;


import java.util.Set;
import java.util.TreeMap;
import java.util.stream.Stream;

import javafx.print.Collation;

public class Demo2 {

	public static void main(String[] args) {
		String s = "abcdbbdbjshhjjajjssjjnckeokjd";
		char[] arr = s.toCharArray();
		Map<Character, Integer> map = new TreeMap<>();
		for (char c : arr) {
			Integer value = map.get(c);
			if(value == null) {
				map.put(c, 1);
			}else {
				map.put(c, value+1);
			}
			//System.out.println(c);
			
		}
		
		 List<Map.Entry<Character, Integer>> list = new ArrayList<Map.Entry<Character, Integer>>(map.entrySet());
	        Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
	            @Override
	            public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
	                return o1.getValue() - o2.getValue();
	            }
	        });
		for (Entry<Character, Integer> entry : list) {
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
	}

}

四、泛型

4.1作用

① 将运行时产生的异常转换为编译期的错误；
② 提高代码的健壮性。

4.2 泛型类

泛型类：表示类中有一个未知的类型；
定义方式：
public class 类名 < T >{}
T表示的是一种类型，是泛型的类型参数，可以使用任意标识，一般使用T、E、K、V等
使用语法：
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

class Base<T>{
	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}	
}

public class Demo3 {

	public static void main(String[] args) {
		Base<Integer> ba = new Base<Integer>();
		ba.setT(1);
		System.out.println(ba.getT());//输出结果为1
	}
}

4.3 泛型方法

使用语法：
修饰符 <类型> 返回值类型方法名(类型变量名){}

class Result {
	<T>void add(T t) {
	}
}

注意当方法静态时，不能访问类上定义的泛型。
如果静态方法使用泛型，只能将泛型定义在方法上。

五、集合框架工具类

5.1 Collections

集合之间的相互转换
1.数组转成集合，本质上依然是一个数组,长度是不可变的；
2.集合与数组所具备的方法是不一样的，如对于数组而言，就没有判断内部包含哪个元素·。

package com.cxy.map;

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

public class Demo4 {

	public static void main(String[] args) {
		 String[] arr = {"a","b","c","d"};
		 List<String> list = Arrays.asList(arr);
		//Object[] array = list.toArray();
		 list.add("e");
		//在原本的数组里加入数据就会报：java.lang.UnsupportedOperationException
		 System.out.println(list.size());
	}
}

5.2 Arrays

① sort
② tostring

package com.cxy.map;

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

/**
 * 对于工具类一些其他方法的应用
 * sort
 * toString
 */
public class Demo5 {

	public static void main(String[] args) {
//		List<String> arrayList = new ArrayList<>();
//		arrayList.add("b");
//		arrayList.add("c");
//		arrayList.add("a");
//		System.out.println(arrayList);
//		Collections.sort(arrayList);
//		System.out.println(arrayList);
//		
//		//这里x,y是指集合中的元素
//		Collections.sort(arrayList,(x,y)->y.compareTo(x));
//		System.out.println(arrayList);
		
		List<Person> list = new ArrayList<>();
		list.add(new Person("b", 18));
		list.add(new Person("c", 21));
		list.add(new Person("a", 19));
	
		System.out.println(list);
		//Collections.sort(list) 这里如果直接放list，会报编译错误，原因是为实现Comparable接口
		Collections.sort(list, (x,y)->x.getName().compareTo(y.getName()));
		System.out.println(list);
		
		//tostring的使用
		Integer[] arr = {3,6,4,9,7,2};
		Arrays.sort(arr,(x,y)->y-x );;
		System.out.println(Arrays.toString(arr));
		//运行结果：[9,7,6,4,3,2]
	}
}
class Person implements Comparable<Person>{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	@Override
	public int compareTo(Person o) {
		return o.getName().compareTo(this.name);
	}
	
}

运行结果：