Day

散列表：可以理解为数组中保存的每个元素都是一个链表
散列表中保存的是键值对（K和V）
  
        添加过程：
        1.先调用添加的K，调用hashCode生成hash值
        2.根据hash值计算数组下标
        3.判断数组中该下标对应的的位置上是否有元素
                3.1如果没有保存数据，就把该对象放到对应的下标中
                3.2如果保存了数据，此时调用添加的K的equals方法，和数组中该下标对应的所有数据的key值进行比较
                3.3如果和数组下标对应的链表中的数据都不想等，就把该数据添加到对应的链表中】
                3.4如果和链表中的数据一致了，则key不添加，把value值替换（用新的替换原来的）
        4.java1.8新改动，如果该链表中节点个数大于7，则该链表被自动转换为红黑树
  
        在java中没有散列表这个说法，只是把散列表封装为了HashMap和HashTable,并且HashTable已经过时
        HashSet底层就是一个HashMap，并且只是Map的key部分，没有value

static class Node implements Map.Entry{
    final int hash;//key的hash值
    final K key;//key
    V value;//value
    Node next;//下一个节点

import java.util.HashSet;

public class Collection_01_HashSet {
	public static void main(String[] args) {
		HashSet set = new HashSet();
		set.add("123");
		set.add("123");
		set.add("1");
		set.add("2");
		set.add("3");
		System.out.println(set.size());
	}
}

package com;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Collection_02_HashSet {

	public static void main(String[] args) {
		//规定姓名相同认为是同一个对象
		User u1 = new User(18,"张三");
		User u2 = new User(20,"张三");
		Set users = new HashSet();
		users.add(u2);
		users.add(u1);
		
		System.out.println(users.size());
		for (User user : users) {
			System.out.println();
		}
	}

}

class User{
	
	@Override
	public int hashCode() {
		return Objects.hash(age, name);
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		return age == other.age && Objects.equals(name, other.name);
	}
	
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}
	
	private int age;
	private String name;
	
	public User(int age,String name) {
		super();
		this.age = age;
		this.name = name;
		
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

Map：无序，key不可重复，value可重复
Map和Collection不一样，但是操作基本上是一样的
集合保存单个对象，而Map保存映射关系

        put(K,V)；添加数据
        remove(K)：删除数据
        clear()：清空
        size()：个数
        isEmpty()：判断是否为空
        get(K)：根据key获取value
        values()：获取所有value，返回集合
        containsKey()：判断是否包含某个key
        containsValue()：判断是否包含某个value
        Set keySet()：获取map中的所有key，返回set
        Set entrySet()：获取map中的键值对，返回set

public class Map_03_HashMap {

	public static void main(String[] args) {
		//创建map
		Map map = new HashMap();
		map.put("q", 1);
		map.put("q", 2);
		map.put("A", 21);
		map.put("'A'", 20);
		map.put("65", 23);
		//个数为4
		System.out.println(map.size());
		//根据key获取value      2,因为key重复，value替换
		System.out.println(map.get("q"));
		//是否包含某个key
		System.out.println(map.containsKey("65"));
		//是否包含某个value
		System.out.println(map.containsValue(20));
		//根据key删除该映射关系(K和V都删除，相当于在链表中把该节点删除)
		map.remove("q");
		//3
		System.out.println(map.size());
		
		//map不能直接遍历，要获取所有的value
		 Collection values = map.values();
		 for (Object object : values) {
			 //3，20，21，23
			System.out.println(object);
			
		//获取所有的key
			Set> entries = map.entrySet();
			for (Entry entry : entries) {
				System.out.println(entry);
				System.out.println(entry.getKey()+"-->"+entry.getKey());
			}
		}
	}
}

Properties：key和value强制要求必须是字符串

public class Map_04_Properties {

	public static void main(String[] args) {
		Properties p = new Properties();
		//添加数据
		p.setProperty("driver", "mysql");
		p.setProperty("username", "root");
		//获取数据
		System.out.println(p.getProperty("driver"));
		System.out.println(p.getProperty("username"));
		//不存在key的时候得到null
		System.out.println(p.getProperty("qwewqeqw"));
		//有个方法重载，第二个参数为默认值，假如找不到key时就返回该默认值，为不是null
		//返回默认值的时候并不会添加进去
		System.out.println(p.getProperty("qwewqeqw","123"));
		//
	}
}

TreeMap : 保存的元素可以按照一定的规则进行排序 排序 :

1.要添加的元素 实现了Comparable接口

2.编写比较器类,实现Comparator接口 treeMap 在添加的时候会自动调用key对象的compareTo方法,是用key进行比较,而不是value

package com;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Map_05_TreeMap {

	public static void main(String[] args) {
		TreeMap map = new TreeMap(new Comparator() {
			public int compare(Integer o1, Integer o2) {
				return o1 - o2;
			}
		});
		map.put(1, "a");
		map.put(2, "a");
		map.put(3, "a");
		map.put(4, "a");
		
		Set set = map.entrySet();
		for (Object object : set) {
			System.out.println(object);
		}
	}
}

package com;

import java.util.ArrayList;
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;


public class Map_06_MapToList {

	public static void main(String[] args) {
		Map map = new HashMap();
		map.put("a", 1);
		map.put("qqq", 2);
		map.put("zzz", 1);
		map.put("aq", 12);
		// 把K和V封装到entry中去，然后保存到set中
		Set> set = map.entrySet();
		// set转换为list
		List> list = new ArrayList>(set);
		// 更改排序
		Collections.sort(list, new Comparator>() {
			public int compare(Entry o1, Entry o2) {
				return o1.getValue() - o2.getValue();
			}
		});
		System.out.println(list);
	}
}