Java Map

散列表 : 可以理解为数组保存元素是个链表

散列表中保存的是键值对(K和V)

hashCode : hash算法, 是把不定长的数据改变为定长的数据,是一种安全的加密算法,但不保证唯一

  同一个对象生成多次hash值, 那么值一定是相同的

  不同的对象也有可能生成相同的hash值

添加过程 : 

1. 先调用添加的K,调用hashCode生成hash值

2. 根据hash值计算数组下标

3. 判断数组中该下标对应的位置上是否有元素

3.1 如果没有保存数据 ,就把该对象放到对应的下标中

3.2 如果保存了数据 , 此时调用添加的K的equals方法,和数组中该下标对应的所有数据的key进行比较

3.3如果和数组下标对应的链表中的数据 , 都不相等,就i吧该数据添加到对应的链表中

3.4 如果和链表中的数据一致了,则key不添加,把value值替换(用新的替换原来的)

4. Java1.8新改动,如果该链表中,节点个数大于7,则该链表被转换为红黑树

在Java中没有散列表这个说法 ,只是把散列表封装为HashMap和HashTable,并且Hash Table已经过时了

并且HashMap的默认值为16 

public class Collection_01_HashSet {
	public static void main (String [] args){
		HashSet set = new HashSet();
		set.add("111");
		//相同的元素不会被添加进去 , 不添加
		set.add("111");
		set.add("123");
		set.add("456");
		System.out.println(set.size());
		for (String str : set){
			System.out.println(str);
		}
	}
}

package com;

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

public class Collection_02_HashSet {

	public static void main(String[] args) {
		//规定姓名相同认为是同一个对象
		User u1 = new User(18,"IU 李知恩");
		User u2 = new User(28,"IU 李知恩");
		Set users = new HashSet();
		users.add(u1);
		users.add(u2);
		// 1 
		System.out.println(users.size());
		for(User user : users){
			//User [age=18, name=IU 李知恩]
			//说明当value一样时,key是不添加的而 不是替换
			System.out.println(user);
		}

		
	}

}
class User{
	private int age;
	private String name;
	//有参构造
	public User(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	//toString
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@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;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}

Map : 无序 , key 不可重复,value值可以重复

Map和Collection不一样, 但是操作基本上是一样的

集合保存单个对象,而map保存键值对 映射关系

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

public class Map_03_HashMap {

	public static void main(String[] args) {
		//创建map  Map: 父类         HashMap : 子类
		Mapmap  =new HashMap();
		//添加元素
		map.put("a", 1);
		map.put("a", 2);
		//不添加
		map.put("A", 12);
		map.put("'A'", 23);
		map.put("65", 123);
		System.out.println(map);
		//个数 4
		System.out.println(map.size());
		//根据key获取value ,  K-->V   因为key重复 ,value替换  2 
		System.out.println(map.get("a"));
		//是否包含某个key   true
		System.out.println(map.containsKey("a"));
		//是否包含某个value   true
		System.out.println(map.containsValue(2));
		//根据key删除该映射关系(K和V都删除 , 在链表中把该节点删除)
		map.remove("a");
		System.out.println(map.size());
		System.out.println(map);
		//map不能直接遍历
		//获取所有value
		Collection values  = map.values();
		for (Object obj : values){
			System.out.println(obj);
		}
		//获取所有的key
		Set sets = map.keySet();
		for (String key : sets){
			System.out.println(key+":"+map.get(key));
		}
		//将map转换为set,并把key和value封装到了entry类对象中,然后把entry类对象保存到set中即可
		Set>entries = map.entrySet();
		for(Entry entry : entries){
			System.out.println(entry);
			System.out.println(entry.getKey()+"-->"+entry.getValue());
		}
	}
}

package com;

import java.util.Properties;


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"));
		//mysql   根据key获取value
		System.out.println(p.getProperty("usename"));
		//不存在这个key找不到对应的value , 返回null
		//有个方法重载,第二个参数为默认值,假如根据key找不到数据的时候,返回该默认值,而不是null
		System.out.println(p.getProperty("asdfss", "我是默认值"));
	}

}

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) {
		TreeMapmap = new TreeMap( new Comparator(){

			@Override
			public int compare(Integer o1, Integer o2) {
				return o1-o2;
				//如果该方法返回 0 说明相等,不再添加
				//如果该方法返回 小于 0 说明要添加的元素比集合中的元素小,就放前面
				//如果该方法返回 大于0 说明要添加的元素比集合中的元素大, 就放后面
			}
		});
		map.put(1, "a");
		map.put(2, "a");
		map.put(12, "a");
		map.put(11, "a");
		map.put(13, "a");
		Set set = map.entrySet();
		for(Object object : set){
			System.out.println(object);
//			13=a
//					12=a
//					11=a
//					2=a
//					1=a
		}

	}

}

package com;

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


public class Map_06_MapToList {

	public static void main(String[] args) {
		// 创建对象
		Map map = new HashMap();
		map.put("a", 1);
		map.put("bbb", 2);
		map.put("bcd", 1);
		map.put("a1", 12);
		// 把K和V封装到entry中,然后保存到set中
		Set> set = map.entrySet();
		// set 转换为 list
		List> list = new ArrayList>(
				set);
		// 更改排序
		Collections.sort(list, new Comparator>() {

			@Override
			public int compare(Entry o1,
					Entry o2) {
				//按照value值进行比较
				return o1.getValue()-o2.getValue();
			}
		});
		System.out.println(list);
		//[a=1, bcd=1, bbb=2, a1=12]
		for(Object obj : list){
			System.out.println(obj);
		}
	}

}