【JavaSE笔记】集合(五)_Map

本期知识点：
Map及其相关
Collections集合工具类

1.Map

a.概述

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

b.Map和Collection的区别?

i.Map集合，是一种键值对的一种映射关系。存储的是键值对的形式的元素。键是唯一的，值可以重复。

HashMap TreeMap 子实现类

ii.Collection集合是集合框架的顶层接口。存储的是单独出现的元素。子接口List元素可以重复，子接口Set元素唯一。

ArrayList Vector LinkedList 子实现类

c.Map接口功能

A:添加功能：

V put(K key,V value)   添加元素(键和值的具体元素)

其他用法:如果键是第一次存储的时候,返回值null(小细节) 如果键已经存在,再次存储的时候将第一次的值返回,并且后面的值覆盖掉前面的值

B:删除功能：

void clear()   从此映射中移除所有映射关系(移出所有的键和值)

V remove(Object key)   删除键,返回值

C:判断功能：

boolean containsKey(Object key) 判断当前Map集合中是否存在key:键

boolean containsValue(Object value)判断当前Map姐中是否存在value:值

D:获取功能：

V get(Object key)  返回指定键所映射的值

Set<K> keySet()  获取所有的键的集合

Collection<V> values()  获取所有的值的集合

Set<Map.Entry<K,V>>

E:长度功能：

int size()

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

public class 获取功能 {
	public static void main(String[] args) {
		//创建Map集合对象
		Map<String, String> m = new HashMap<String,String>();
		//添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		
		//V get(Object key)返回指定键所映射的值
		String a = m.get("Ash");
		System.out.println("Values:"+a);
		
		//Set<K> keySet():获取所有的键的集合
		Set<String> k = m.keySet();
		System.out.println("AllKey:"+k);
		
		//Collection<V> values():获取所有的值的集合 
		Collection<String> v =m.values();
		System.out.println("AllValues:"+v);
	}
}
//out:
//Values:Thermite
//AllKey:[Blitz, Twitch, Ash, Glaz]
//AllValues:[IQ, Montagne , Thermite, Fuze]

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

public class 添加删除长度功能 {
	public static void main(String[] args) {
		Map<String,String> m = new HashMap<String,String>();
		//给集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//void clear() 移除所有映射关系
//		m.clear();
//		System.out.println(m);//{}
		
		//V remove(Object key):删除键,返回值
		System.out.println(m.remove("Ash"));//Thermite
		System.out.println(m.remove("Glaz"));//Fuze
		System.out.println(m);//{Blitz=IQ, Twitch=Montagne }
		
		//int size();
		System.out.println(m.size());//2
	}
}

d.Map集合的遍历

i:键找值

1):获取所有键的集合

2):遍历键的集合,得到每一个键

3):根据键到集合中去找值

ii:键值对对象找键和值

1):获取所有的键值对对象的集合

2):遍历键值对对象的集合，获取每一个键值对对象

3):根据键值对对象去获取键和值

4):接口 Map.Entry<K,V>:(正在封闭接口：Map<K,V>)

public static interface Map.Entry<K,V>

映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。

方法：

boolean equals(Object o)   比较指定对象与此项的相等性。如果给定对象也是一个映射项，并且两个项表示相同的映射关系，则返回 true。

K getKey()   与此项对应的键

V getValue()   返回与此项对应的值。如果已经从底层映射中移除了映射关系（通过迭代器的 remove 操作），则此调用的结果是不确定的。

i.

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

public class Map集合的遍历_键找值 {
	public static void main(String[] args) {
		//创建Map集合对象
		Map<String, String> m = new HashMap<String,String>();
		//给集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//获取所有键的值
		Set<String> s = m.keySet();
		//遍历所有键的集合
		for (String k : s) {
			String v = m.get(k);
			System.out.println(k+"---"+v);
		}
	}
}
//out:
//	Blitz---IQ
//	Twitch---Montagne 
//	Ash---Thermite
//	Glaz---Fuze

ii.

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

public class Map集合的遍历_键值对对象找键和值 {
	public static void main(String[] args) {
		//创建Map集合对象
		Map<String, String> m = new HashMap<String,String>();
		//给集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//获取 键值对 对象的集合
		Set<Entry<String, String>> s = m.entrySet();
		//遍历 键值对 对象的集合
		for (Entry<String, String> me : s) {
			//键值对 对象中有两个方法 关于 Key 和 Values
			//K getKey():获取键
			//V getValue():获取值
			String key = me.getKey();
			String values = me.getValue();
			System.out.println(key+"---"+values);
		}
	}
}
//out:
//	Blitz---IQ
//	Twitch---Montagne 
//	Ash---Thermite
//	Glaz---Fuze

2.Map集合体系图：

3.HashMap的嵌套

a.ArrayList-HashMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class ArrayList_HashMap {
	public static void main(String[] args) {
		ArrayList<HashMap<String, Integer>> a = new ArrayList<HashMap<String, Integer>>();
		
		HashMap<String, Integer> m = new HashMap<String,Integer>();
		
		m.put("Ash", 22);
		m.put("Fuze", 23);
		m.put("Glaz", 22);	
		
		a.add(m);
		//ArrayList迭代器
		Iterator<HashMap<String, Integer>> it = a.iterator();
		while(it.hasNext()){
			HashMap<String, Integer> n = it.next();
			Set<String> keySet = n.keySet();
			for (String key : keySet) {
				Integer values = n.get(key);
				System.out.println(key+"---"+values);
			}
		}
		System.out.println("-----------");
		//增强for
		for (HashMap<String, Integer> hm : a) {
			Set<String> keySet = hm.keySet();
			for (String k : keySet) {
				Integer values = hm.get(k);
				System.out.println(k+"---"+values);
			}
		}
	}
}
//out:
//	Ash---22
//	Fuze---23
//	Glaz---22
//	-----------
//	Ash---22
//	Fuze---23
//	Glaz---22








b.HashMap-HashMap

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

public class HashMap_HashMap {
	public static void main(String[] args) {
		HashMap<String, HashMap<String, Integer>> hm = new HashMap<String, HashMap<String, Integer>>();
		
		HashMap<String, Integer> m1 = new HashMap<String, Integer>();
		
		m1.put("Tom", 20);
		m1.put("Peter", 21);
		
		hm.put("自动化", m1);
		HashMap<String, Integer> m2 = new HashMap<String, Integer>();
		
		m2.put("Ash", 22);
		m2.put("Rook", 21);
		
		hm.put("计算机", m2);
		//遍历
		Set<String> hms = hm.keySet();
		for (String hmk : hms) {
			System.out.println(hmk);
			HashMap<String, Integer> hmv = hm.get(hmk);
			Set<String> hmss = hmv.keySet();
			for (String hmkk : hmss) {
				Integer hmvv = hmv.get(hmkk);
				System.out.println(hmkk+"---"+hmvv);
			}
		}
		}
}
//out:
//	自动化
//	Tom---20
//	Peter---21
//	计算机
//	Ash---22
//	Rook---21




c.HashMap-ArrayList

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMap_ArrayList {
	public static void main(String[] args) {
		HashMap<String, ArrayList<String>> m = new HashMap<String, ArrayList<String>>();
		ArrayList<String> a = new ArrayList<String>();
		a.add("Ash");
		a.add("Glaz");
		a.add("Fuze");
		
		m.put("进攻方", a);
		
		Set<String> keySet = m.keySet();
		for (String key : keySet) {
			System.out.println(key);
			ArrayList<String> values = m.get(key);
			for (String vkey : values) {
				System.out.println(vkey);
			}
		}
	}
}
//out:
//	进攻方
//	Ash
//	Glaz
//	Fuze

d.Hashtable和HashMap的区别:

HashMap集合:允许有null键和null值,从线程的角度考虑:他是一个线程不安全,不同步,执行效率高

Hashtable集合:不允许有null键,从线程的角度考虑:他是一个线程安全的,同步,效率低

4.TreeMap

TreeMap:基于红黑树结果

两种排序:自然排序,比较器排序

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

public class TreeMapDemo {
	public static void main(String[] args) {
		//创建TreeMap集合对象
		TreeMap<String, Integer> t = new TreeMap<String, Integer>();
		//添加元素
		t.put("Ash", 21);
		t.put("Fuze", 21);
		t.put("Glaz", 21);
		t.put("Tom", 21);
		//遍历
		Set<String> keySet = t.keySet();
		for (String k : keySet) {
			Integer v = t.get(k);
			System.out.println(k+"---"+v);
		}
	}
}
//out:
//	Ash---21
//	Fuze---21
//	Glaz---21
//	Tom---21

public class Student {
	private String name;
	private int age;
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
	
}
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapStudentDemo {
	public static void main(String[] args) {
		TreeMap<Student, String> t = new TreeMap<Student, String>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				//按照年龄大小排序
				int a = o1.getAge()-o2.getAge();
				//按照名字内容
				int b = a == 0? o2.getName().compareTo(o1.getName()):a;
				return b;
			}
		});
		//创建学生对象
		Student s1 = new Student("Tom",21);
		Student s2 = new Student("Ash",22);
		Student s3 = new Student("Peter",20);
		Student s4 = new Student("Rush",21);
		//添加
		t.put(s1, "自动化");
		t.put(s2, "自动化");
		t.put(s3, "计算机");
		t.put(s4, "计算机");
		
		//获取所有的键的集合
		Set<Student> keySet = t.keySet();
		for (Student k : keySet) {
			String v = t.get(k);
			System.out.println(k.getName()+"---"+k.getAge()+"---"+v);
		}
		
	}
}
//out:
//	Peter---20---计算机
//	Tom---21---自动化
//	Rush---21---计算机
//	Ash---22---自动化

5.Collections

a.概述:

对集合操作的工具类

b.Collections和Collection的区别?

Collection:集合:顶层次的一个根接口,有两个子接口:List,Set

Collections:对集合操作的工具类,具体的类:它针对集合进程操作!

c.方法：

public static <T> void sort(List<T> list)   默认自然排序:将集合中的元素升序排序

public static <T> int binarySearch(List> list,T key)  二分查找搜索法:key:查找的元素

public static void reverse(List list)  反转功能

public static void shuffle(List<?> list)   随机置换,打乱顺序

import java.util.ArrayList;
import java.util.Collections;

public class Demo01 {
	public static void main(String[] args) {
		ArrayList<Integer> a = new ArrayList<Integer>();
		//添加元素:
		a.add(20) ;
		a.add(17);
		a.add(19) ;
		a.add(18) ;
		a.add(24) ;
		a.add(23) ;
		a.add(22) ;
		System.out.println(a);
//		public static <T> void sort(List<T> list)		
//		默认自然排序:将集合中的元素升序排序
		Collections.sort(a);
		System.out.println(a);
//		public static <T> int binarySearch(List> list,T key):二分查找搜索法:key:查找的元素
		int index = Collections.binarySearch(a, 20);
		System.out.println(index);
//		public static void reverse(List list):反转功能
		Collections.reverse(a);
		System.out.println(a);
//		public static void shuffle(List<?> list):随机置换,打乱顺序
		Collections.shuffle(a);		
		System.out.println(a);
	}
}