Map集合

映射:某两个元素存在一一对应的关系，我们称之为映射

java为这种关系是提供了专门的集合类来存放这种关系的对象，即java.util.Map 接口

Map中的集合元素是成对出现的(双例集合)，（可以变相的理解为夫妻），每对夫妻都是由键值对组成，也就是kv形式，通过键可以找到对应的值。需要注意的的是:每对元素中，键不能重复，值可以重复。

其中Map中的两个常用子类：

• HashMap<k,v>：存储数据采用哈希表结构，元素的存储数据顺序不能保持一致，由于要保持键的唯一性和不重复方性需要重写hashCode()方法和equals()方法。
• LinkedHashMap<k,v>：LinkedHashMap是HashMap的子类，存储数据采用哈希表结构，通过链表结构元素的存储数据顺序能保持一致，通过哈希表保持键的唯一性和不重复方性需要重写hashCode()方法和equals()方法。

提示：Map接口在使用时有两个泛型变量，要为两个泛型变量赋值数据类型，数据类型可以相同，也可以不同

Map接口方法展示：

HashMap

import java.util.HashMap;
import java.util.Set;
import javax.swing.plaf.basic.BasicScrollPaneUI.HSBChangeListener;
import jdk.internal.org.objectweb.asm.tree.analysis.Value;
import java.util.Map.Entry;
public class MapTest01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建Map对象
		HashMap<String, String> hashMap = new HashMap<String,String>();
		
		//添加键值对到hashMap集合中
		hashMap.put("张三", "张三妻子");
		hashMap.put("李二", "李二妻子");
		hashMap.put("王三", "王三妻子");
		hashMap.put("赵四", "赵四妻子");
		
		//判断集合是否为空，为空返回true，不为空返回false
		System.out.println(hashMap.isEmpty());
		
		//查看hashMap集合
		System.out.println(hashMap);
		
		//查看hashMap集合中某键对应的的值
		System.out.println(hashMap.get("李二"));//查看hashMap集合中李二对应的的值
		
		//判断集合中是否存在这个键
		System.out.println(hashMap.containsKey("钱六"));//用布尔值表示
		
		//判断集合中是否存在这个值
		System.out.println(hashMap.containsValue("钱六妻子"));//用布尔值表示
		
		//获得键值对的对数数
		System.out.println(hashMap.size());
		
		//移除某个键值对,返回被删除的值
		System.out.println(hashMap.remove("赵四"));
		//查看hashMap集合
		System.out.println(hashMap);//发现赵四键值对果然不见了
		
//		//删除所有的键值对
//		hashMap.clear();
//		System.out.println(hashMap.isEmpty());
//		System.out.println(hashMap);//果然为空了

		
	}

}

　结果：

false
{王三=王三妻子, 李二=李二妻子, 赵四=赵四妻子, 张三=张三妻子}
李二妻子
false
false
4
赵四妻子
{王三=王三妻子, 李二=李二妻子, 张三=张三妻子}

 

提示：使用put方法的时候需要注意，若指定的键在集合中没有，就会返回null，并把新的键值添加到集合中；若指定的键在集合中存在，就会返回存在键的值(旧的键值)，并把旧的值替换掉。

public class MapTest02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建Map对象
		HashMap<String, String> hashMap = new HashMap<String,String>();
				
		//添加键值对到hashMap集合中
		hashMap.put("张三", "张三妻子");
		hashMap.put("李二", "李二妻子");
		hashMap.put("王三", "王三妻子");
		hashMap.put("赵四", "赵四妻子");
		System.out.println(hashMap);
		hashMap.put("王三", "王三wifi");
		System.out.println(hashMap);
	}

}

　　结果：

{王三=王三妻子, 李二=李二妻子, 赵四=赵四妻子, 张三=张三妻子}
{王三=王三wifi, 李二=李二妻子, 赵四=赵四妻子, 张三=张三妻子}

　

遍历键找值：

1. 获取Map中所有的键，由于键是唯一，所以返回一个Set集合存储所有的键。方法：keyset();
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取对应的值　　　　　　　　

//遍历键找值
		//将hashMap集合装入key键集
		Set<String> keys = hashMap.keySet();
		System.out.println(keys);
		//遍历键集
		for (String key:keys) {
			String value = hashMap.get(key);
			System.out.println(key+"的对象是"+value);
		}

　　结果：

王三的对象是王三妻子
李二的对象是李二妻子
张三的对象是张三妻子

　　

　　遍历图解：

 

 

 集合遍历键值对方式

1. 获取Map集合中，所有键值对Entry对象，以Set集合方式返回。方法：entrySet()
2. 遍历键值对对象的Set集合，得到每一个键值对对象。
3. 通过键值对对象，获取对象中的键和值，方法：: getkey() getValue()　

		//获取hashMap集合中所有键值对，存储到entrySet
		Set<Entry<String,String>> entrySet = hashMap.entrySet();
		for (Entry<String,String> entry:entrySet) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+"的wife是"+value);
		}

　　结果：

王三的wife是王三妻子
张三的wife是张三妻子
李二的wife是李二妻子

　　遍历图解：

 

 

 HashMap自定义存储键值对型

• 当给HashMap自定义存储对象时，就必须要保证对象得唯一性，就必须重写　hashCode() 方法和  equals() 方法  
  　

public class Student {
 private String name;
 private int age;
 public Student() {
 }
 public Student(String name, int age) {

 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;
 }
 @Override
 public boolean equals(Object o) {
 if (this == o)
 return true;
 if (o == null || getClass() != o.getClass())
 return false;
 Student student = (Student) o;
 return age == student.age &&
 Objects.equals(name, student.name);
 }
 @Override
 public int hashCode() {
 return Objects.hash(name, age);
 }
}

　　编写测试类：

public class HashMapTest {
 public static void main(String[] args) {
//创建map对象集合
 Map<Student,String>map = new HashMap<Student,String>();

//添加元素
map.put(new Student("王麻子",28), "成都");
 map.put(new Student("张三",22), "上海");
 map.put(new Student("李二",24), "广州");
 map.put(new Student("王二",25), "深圳");
map.put(new Student("赵四",22), "北京");

//取出元素键找值得方式
Set<Student>keySet = map.keySet();
 for(Student key: keySet){
 String value = map.get(key);
 System.out.println(key.toString()+"....."+value);
 }
 }
}

　LinkedHashMap类

• 可以保证存放的key和取出的顺序一致，并且查询很快，也能保证key的唯一性。

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

public class LinkedMapTest02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
		 map.put("张三","张三老婆");
		 map.put("李四","李四老婆");
		 map.put("王五","王五老婆");
		 
		 Set<Entry<String,String>> entrySet = map.entrySet();
		 
		 for (Entry<String, String> entry : entrySet) {
		 System.out.println(entry.getKey() + " " + entry.getValue());
		 }
	}

}

　　结果：

张三 张三老婆
李四 李四老婆
王五 王五老婆