Map-键值对，对应关系；Sort-排序改变对应值

回顾：
集合的整个架构
Collection
|- List (有序线性列表，可重复)
|- ArrayList (数组-顺序结构，标号，连续的物理空间)
|- LinkedList (节点-链表结构，head - next)
|- Vector (同ArrayList，多个锁)
|- Set (不可重复)
|- HashSet (无序散列表) hashCode() equals()
|- TreeSet (二叉树-中序遍历) 从小到大 - 比较Comparable - compareTo
|- Queue (队列：先进先出)
|- Deque / Stack (栈：先进后出)
(双端队列：两边都可以进出)

选择集合的要素：
集合是否允许重复
是否有顺序
是否要排序

---

TreeSet
能添加到TreeSet的元素，必须是可比较的 Comparable

ArrayList
数组排序：
1.插入排序
数组分为两部分，后部分每一个元素和前部分每一个元素比较，插入到合适位置
2.冒泡排序
比较相邻两个元素
3.选择排序
每一轮都找到最小的元素放在前面

字符串 String StringBuilder
时间 Date Calendar DateFormat
数组 Arrays - 静态方法 - 工具类
toString() - 打印
sort() - 排序
随机数 Random r = new Random()
r.nextInt(100) - (0~99)
数学 Math - 工具类
Math.random() - 随机数 [0,1) * 100
Math.floor(double) - 向下取整
.ceil(double) - 向上取整
.round(double) - 四舍五入
绝对值
开根号
次方
正弦、余弦
系统 System.out/in/err
.arraycopy()

---

Arrays.sort(int[])
Collections - 工具类
sort(List) -> 底层调用 Arrays.sort()
1.判断Comparator == null
为空：数组对象强转成Comparable对象，compareTo比较
2.不为空：指定比较器 Comparator
通过比较器的compare方法比较

结论：如果指定比较器，对象不需要实现Comparable接口
	 没有指定比较器，必须要实现Comparable接口

匿名内部类：没有名字的内部类
意义：继承抽象类或者实现接口

集合：
Collection
Map：键值对 key - value 映射表
HashMap
Hashtable
ConcurrentHashMap
LinkedHashMap
SortedMap(I) -> TreeMap

put(key, value)
value get(key)	
remove(key)
	
keySet()
entrySet()
values()

作业：
1.Day05 全部
2.牛客网 - 选择日常作业
3.数组排序 代码
4.思维导图
5.之前代码里面涉及到的面试问题
CSDN — Java常见面试题

面试题：
1.HashMap、Hashtable、ConcurrentHashMap、LinkedHashMap的区别
2.HashMap的底层实现原理

键值对，对应关系。

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import org.junit.Test;

import java_05.User;

public class MapDemo {
@Test
public void test01() {//随机输出。 修改 删除 返回的值是 被修改 和 被删除 的值。
Map<String,String> map = new HashMap<String,String>();
//增 删 改 查
map.put(“haha”, “0”);
map.put(“hehe”, “1”);
map.put(“lala”, “12”);
map.put(“xixi”, “123”);
map.put(“hihi”, “1234”);
map.put(“gaga”, “12345”);
map.put(“gugu”, “123456”);
//修改 – 返回的是被修改的value值
String s = map.put(“gugu”, “1234”);
System.out.println(s);
// xx = xx xx:xx ->map 这种类型都是map
System.out.println(map);

	//通过key获取value；
	String value = map.get("haha");
	System.out.println(value);
	
	//通过key删除 key - value - 返回被删除的value值
	String s2 = map.remove("haha");
	System.out.println(s2);
	
}
@Test
public void test02() {//按Integer顺序输出 迭代遍历   map.keySet();
	Map<Integer,String> map = new HashMap<Integer,String>();
	map.put(1, "zhangsan");
	map.put(2, "lisi");
	map.put(4, "zhaoliu");
	map.put(3, "wangwu");

	
	System.out.println(map);
	
	Set<Integer> keys = map.keySet();//将 1 ，2 ，3 ，4 给keys。
	Iterator<Integer> it = keys.iterator();
	while(it.hasNext()) {//迭代器
		Integer key = it.next();
		
		System.out.println(key + "="+map.get(key));
	}
}
@Test
public void test03() {//随机输出 ，迭代器遍历  map.values()
	Map<String,String> map = new HashMap<String,String>();
	map.put("zhang", "san");
	map.put("li", "si");
	map.put("wang", "wu");
	map.put("zhao", "liu");
	System.out.println(map);
	//获得value对应的collection视图。
	Collection<String>col = map.values();
	for(String str:col) {//简易迭代器。
		System.out.println(str);
	}
}
@Test
public void test04() {//按entrySet迭代遍历
	//键值关系 key - value -> Set
	Map<String,User>map = new HashMap<String,User>();
	map.put("laowang", new User("lucy",19));
	map.put("lucy", new User("tom",20));
	map.put("laoli", new User("jerry",22));
	map.put("laoliu", new User("jane",26));
	map.put("laotie", new User("berry",20));
	System.out.println(map);
	//entry:key - value 键值关系
	Set<Entry<String,User>>set = map.entrySet();
	for(Entry<String,User> entry : set) {
		/*
		 * entry.getKey(); -- 键值关系中的key
		 * entry.getValue(); -- 键值关系中的value
		 */
		System.out.println(entry.getKey()+"="+entry.getValue());
	}
}
@Test 
public void test05() {//TreeMap排序User的name输出
	TreeMap<User,String> map = new TreeMap<User,String>();
	map.put(new User("lucy",19), "hello");
	map.put(new User("tom",20), "hi");
	map.put(new User("jerry",22), "heihei");
	System.out.println(map);
}
@Test
public void test06() {//LinkedHashMap按输入顺序输出
	Map<String,String> map = new LinkedHashMap<String,String>();
	map.put("ni", "hao");
	map.put("wo", "zai");
	map.put("chi", "fan");
	map.put("wan", "an");
	map.put("shui", "jiao");
	System.out.println(map);
}

}

Sort

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

import org.junit.Test;

import java_05.User;

public class SortDemo {
@Test
public void test01() {
List list = new ArrayList();
list.add(“a”);
list.add(“b”);
list.add(“hello”);
list.add(“jerry”);
list.add(“jane”);
list.add(“c”);
System.out.println(list);

		Collections.sort(list);//排序改变list本身
		System.out.println(list);
}
@Test
public void test02() {
	List<User> list = new ArrayList<User>();
		list.add(new User("jerry",21));
		list.add(new User("lucy",23));
		list.add(new User("jane",24));
		list.add(new User("bob",27));
		list.add(new User("jc",22));
		
		System.out.println(list);
		//编译错误 - User 不是Comparable
		//
		Collections.sort(list,new Comparator<User>() {
			@Override
			public int compare(User u1, User u2) {
				// TODO Auto-generated method stub
				return u1.getAge()-u2.getAge();
			}//内部类
			 //实现Comparator接口
		}    )     ;//排序改变list本身
		System.out.println(list.toString());
}
@Test 
public void test03() {
	//实现这个内部类实现Comparator接口
	//实现接口的抽象方法。
	Comparator<User> c = new Comparator<User>() {//比较器

		@Override
		public int compare(User o1, User o2) {
			// TODO Auto-generated method stub
			return 0;
		}
	};	
	c.compare(new User("lucy", 20), new User("jerry",20));
}

}