Java 基础学习之类集框架八（Map 接口的使用注意事项）

客官°小女子只卖身不卖艺 2024-04-17 16:34 37阅读 0赞

# 1. 注意事项1 —> 不能直接使用迭代输出 Map 中的全部内容 #

对于 Map 接口来说，其本身是不能直接使用迭代（如 Iterator、foreach）进行输出的，因为 Map 中的每个位置存放的是一对值（key —> value）,而 Iterator 中每次只能找到一个值。所以，如果非要使用迭代进行输出，则必须按照以下的步骤完成（以 Iterator 输出方法为例）。  
（1）将 Map 的实例通过 entrySet()方法变为 Set 接口对象。  
（2）通过 Set 接口实例为 Iterator。  
（3）通过 Iterator 迭代输出，每个内容都是 Map.Entry 对象。  
（4）通过 Map.Entry 进行 key —> value 的分离。  
   Map 中的每对数据都是通过 Map.Entry 保存的，所以如果最终要进行输出的话，也应该使用 Map.Entry 完成。下面分别使用 Iterator 和 foreach 进行输出。

## 1.1 Map 输出方式 1：Iterator 输出 ##

#### 实例 1 代码： ####

package self.learn.mapdemo;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class MapDemo { 
    	public static void main(String[] args) { 
    		Map<String,String> map = null;          // 声明 Map 对象，指定泛型类型
    		map = new HashMap<String, String>();    // 实例化 Map 对象
    		map.put("A", "Java Language");          // 增加内容
    		map.put("B", "is interesting");
    		map.put("C", "learn www.com.cn");
    		Set<Map.Entry<String, String>> allSet = null;     // 声明一个 Set 集合，指定泛型
    		allSet = map.entrySet();                          // 将 Map 接口实例变为 Set 接口实例
    		Iterator<Map.Entry<String, String>> iter = null;  // 声明 Iterator 对象
    		iter = allSet.iterator();                         // 实例化 Iterator 对象
    		while(iter.hasNext()) { 
    			Map.Entry<String, String> me = iter.next();   // 找到 Map.Entry 实例
    			System.out.println(me.getKey()+"--->"+me.getValue());
    		}
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][20190829091034130.png]  
   以上的操作流程是 Map 输出最标准的流程，读者一定要牢牢掌握，这一点在以后的开发中非常重要。

## 1.2 Map 输出方式 2：foreach 输出 ##

#### 实例 2 代码： ####

package self.learn.mapdemo;
    
    import java.util.HashMap;
    import java.util.Map;
    public class MapDemo { 
    	public static void main(String[] args) { 
    		Map<String,String> map = null;          // 声明 Map 对象，指定泛型类型
    		map = new HashMap<String, String>();    // 实例化 Map 对象
    		map.put("A", "Java Language");          // 增加内容
    		map.put("B", "is interesting");
    		map.put("C", "learn www.com.cn");
    		for( Map.Entry<String, String> me : map.entrySet())
    			System.out.println(me.getKey()+"--->"+me.getValue());
    	}
    }

#### 运行结果截图： ####

![在这里插入图片描述][20190829091823178.png]  
   上面程序中使用 foreach 语法将集合中的每个元素通过 Map.Entry 类型的对象进行接收，然后再进行 key 与 value。

# 2. 注意事项 2 —> 直接使用非系统类作为 key #

既然在 Map 接口中所有内容都是以 “key —> value” 的形式出现的，而且在声明 Map 对象的时候，也使用了泛型声明类型，那么现在就应该可以使用 “字符串” 表示 key, 用一个 Person 对象表示 value。

#### 实例 3 代码： ####

package self.learn.setdemo;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Person {              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}	
    	
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public static void main(String[] args) { 
    		Map<String,Person> map = null;          // 声明 Map 对象，指定泛型类型
    		map = new HashMap<String, Person>();    // 实例化 Map 对象
    	    map.put("Zhangsan", new Person("张三", 30));
    	    System.out.println(map.get("Zhangsan"));
    	}
    }

#### 运行结果截图 ####

![在这里插入图片描述][20190829092850653.png]  
   上面的程序在操作时是以一个字符串匿名对象的方式查找的，从结果来看，是能够查找到其对应内容的。那么，如果现在两个类型换一下位置呢？即使用一个 Person 对象来表示一个字符串。

#### 实例 4 代码：Person —> String 映射 ####

package self.learn.setdemo;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Person {              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}	
    	
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public static void main(String[] args) { 
    		Map<Person,String> map = null;          // 声明 Map 对象，指定泛型类型
    		map = new HashMap<Person,String>();    // 实例化 Map 对象
    	    map.put(new Person("张三", 30),"Zhangsan" );
    	    System.out.println(map.get(new Person("张三", 30));
    	}
    }

#### 运行结果截图 ####

![在这里插入图片描述][20190829093537786.png]  
   上面的程序结构和之前的类似，只是使用了一个 Person 的匿名对象作为 key, 将字符串的匿名对象作为了 value,唯一不同的只是改变了之前 key 和 value 的位置，但是此时却无法查找到指定的内容，那么为什么一开始用 String 可以，而现在使用 Person 对象不可以。为了研究这个问题，继续观察以下的程序代码：

#### 实例 5 代码：声明 Person 对象 —> String 映射 ####

package self.learn.setdemo;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Person {              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}	
    	
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public static void main(String[] args) { 
    		Map<Person,String> map = null;          // 声明 Map 对象，指定泛型类型
    		map = new HashMap<Person,String>();    // 实例化 Map 对象
    		Person per = new Person("张三", 30);
    	    map.put(per,"Zhangsan" );
    	    System.out.println(map.get(per));
    	}
    }

#### 运行结果截图 ####

![在这里插入图片描述][20190829094714109.png]  
   可以发现，根据 key 找到对应的 value,但是为什么此时可以找到，而之前找不到呢？ 细心的读者可能已经发现了，之前的操作都是以 Person 的匿名对象完成的，但是现在进行查找操作时并不是用匿名对象，这样程序的设置和取得的时候都是使用了 Person 的实例化对象，地址没有改变，所以可以找到。  
   但是不可能所有的程序这样去完成查找功能，用户在操作时不可能明确知道其中某一个 key 的引用地址，应该像 String 那样可以通过匿名对象找到对应的 value,要想实现这样的功能，就要依靠 Object 类中提供的 hashCode() 方法 和 equals() 的帮助，以便区分是否是同一个对象。

#### 实例 6 代码：覆写 equals() 和 hashCode() 方法 ####

package self.learn.setdemo;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Person{              // 定义 Person 类实现比较器
    	private String name;
    	private int age;
    	public Person(String name, int age) { 
    		this.name = name;
    		this.age = age;
    	}		
    	
    	public boolean equals(Object obj) {        // 覆写 equals() 方法
    		if(this == obj) {                      // 地址相等
    			return true;                      // 是同一对象
    		}
    		if(!(obj instanceof Person)) {         // 传递进来的不是本类对象
    			return false;                     // 不是同一对象
    		}
    		Person p = (Person)obj;               // 进行向下转型
    		if(this.name.equals(p.name)&&this.age == p.age) {   // 属性依次比较
    			return true;                                   // 全部属性相等，是同一对象
    		}else {                   
    			return true;                                   // 属性不相等，不是同一对象
    		}		
    	}
    	
    	public int hashCode() {           // 覆写 hashCode() 方法
    		return this.name.hashCode()*this.age;  // 指定编码公式
    	}				
    	@Override
    	public String toString() {                                // 覆写 toString() 方法
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	public static void main(String args[]) { 
    		Map<Person, String> map = null;
    		map = new HashMap<Person, String>();
    		Person per = new Person("张三", 30);
    	    map.put(per,"Zhangsan" );
    	    System.out.println(map.get(new Person("张三", 30)));
    	}	
    }

#### 运行结果截图 ####

![在这里插入图片描述][20190829100114815.png]  
   从结果中可以发现，如果要使用一个自定义的对象表示 Map 中的 key, 则对象所在的类中一定要覆写 equals() 和hashCode() 方法：否则无法找到对应的 value 。

[20190829091034130.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a16a1e7bb1fd493586bdb38f484c4148.png
[20190829091823178.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b8c9fd2283a14e86a6af6a7a66452f91.png
[20190829092850653.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/98851a5a80864aa1ba1d2f529226949e.png
[20190829093537786.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1d9020b1ca354266b011807ea189a789.png
[20190829094714109.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/03e26043469f45cdb1f2ad8323e43a3e.png
[20190829100114815.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/63f16e8360714c43b1c995363a5855b9.png