java中Map集合的四种遍历方式

java中Map集合的四种遍历方式

Map接口和Collection接口的集合不同,Map集合是双列的,Collection是单列的.Map集合将键映射到值的对象.

双列的集合遍历起来也是比较麻烦些的,特别是嵌套的map集合,这里说下MAP集合的四种遍历方式，并且以嵌套的hashMap集合为例, 遍历一下。

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

public class ThreeHashmap {
	public static void main(String[] args) {
		//内层的HashMap inter1
		HashMap<String, Integer> inter1 = new HashMap<String, Integer>();
		inter1.put("张三", 20);
		inter1.put("李四", 22);
		//内层的HashMap inter2
		HashMap<String, Integer> inter2 = new HashMap<String, Integer>();
		inter2.put("王五", 21);
		inter2.put("赵六", 23);
		//外层的HashMap out,里面的键- 值是两个HashMap
		HashMap<HashMap<String, Integer>, HashMap<String, Integer>> out = new HashMap<HashMap<String, Integer>, HashMap<String, Integer>>();
		//外层的HashMap out,放进去hashMap ,键- 值是两个HashMap
		out.put(inter1, inter2);
		

首先是两个hashMap<String, Integer>,然后是一个大的HashMap<HashMap<String, Integer>, HashMap<String, Integer>>, 里面键和值都是hasMap.然后就是去遍历

方式一:根据键找值
1,用keySet()方法 获取所有键的集合Set,
2.遍历键的集合，获取到每一个键key
3.用get(Object key)方法,根据键找到每一个对应的值,然后输出键和值

System.out.println("---方式1:Map.keySet()取得键的set集合,取得键,然后Map.get(key)取得值");
		Set<HashMap<String, Integer>> setout=out.keySet();
		for (HashMap<String, Integer> keyMap : setout) {
			//内层键位的hashMap,遍历
			Set<String> keystrSet = keyMap.keySet() ;
			for (String keystring : keystrSet) {
				Integer keyMapin = keyMap.get(keystring);
				System.out.println(keystring+"\t"+ keyMapin);
			}
			//get(keyMap) 获得对应的值位的 hashMap,然后重复同样的方法遍历
			HashMap<String, Integer> valueMap= out.get(keyMap);
			Set<String> set = valueMap.keySet();
			for (String str : set) {
				Integer in = valueMap.get(str);
				System.out.println(str+"\t"+in);
			}
		}

方式二:根据键值对对象找键和值
1.用entrySet()方法获得值对对象的集合 Set<Map.Entry<K,V>>
2,for循环遍历键值对对象的集合Set<Map.Entry<K,V>>,获得每一个键值对,
3,然后用Entry.getKey()和Entry.getValue()方法取出每个对象中的键和值

//方法2 entryset
		System.out.println("---------方式2:Map.entrySet()配合getKey(),getValue()获得键和值------------");
		Set<Map.Entry<HashMap<String, Integer>, HashMap<String, Integer>>> outentrySET=out.entrySet();
		for (java.util.Map.Entry<HashMap<String, Integer>, HashMap<String, Integer>> entry : outentrySET) {
			HashMap<String, Integer> keyMap = entry.getKey();
			HashMap<String, Integer> valueMap = entry.getValue();
			
			Set<Map.Entry<String,Integer>> keyentrySet = keyMap.entrySet();
			for (Map.Entry<String, Integer> keyentry : keyentrySet) {
				System.out.println(keyentry.getKey()+"\t"+ keyentry.getValue());
			}
			
			Set<Map.Entry<String, Integer>>  valueEntrySet = valueMap.entrySet();
			for (Map.Entry<String, Integer> valueentry : valueEntrySet) {
				System.out.println(valueentry.getKey()+"\t" + valueentry.getValue());
			}
			
		}
		

方式三: 分别获得键 和 值 ,遍历输出
1. map.keySet()获得所有键的集合Set
2. Map.value()取得值的集合Collection
3. 分别用for循环遍历取得每一个键和值.
这种方法的缺点是,取得的键不能和对应的值连到一起,适合只需要键 或者值得时候.

System.out.println("-------------------方式三: Map.keySet(),Map.value()---------------------------");
		//方式三 map.keySet(),		Map.value()只能分别取得键和值的集合,遍历输出键和值,不能连到一起,有缺点,适合于只需要键或值得时候-
		
		//Map.keySet()键位的 hashMap 
		for (HashMap<String, Integer> keyMap : out.keySet()) {
			//-Map.keySet(),Map.value()只能分别取得键和值,不能连到一起,有缺点,适合于只需要键或值得时候-
			for (String string : keyMap.keySet()) {
				System.out.println(string);
			}
			for (Integer integer : keyMap.values()) {
				System.out.println(integer);
			}
			
		}
		//Map.value() 获得值 的  hashMap
		for (HashMap<String, Integer> hashMap : out.values()) {
			for (Entry<String, Integer> entry : hashMap.entrySet()) {
				System.out.println(entry.getKey()+"\t"+ entry.getValue());
				
			}
		}

方式四: 使用获得键值对对象集合+迭代器
1.用entrySet()方法获得值对对象的集合 Set<Map.Entry<K,V>>
2,然后用迭代器Iterator()遍历出每一个键-值对对象
3, 使用Entry.getKey()和Entry.getValue()方法取出每个对象中的键和值
其实和键值对对象配合增强for循环找键和值的方式类似, 没有特殊要求的时候更提倡使用键值对对象配合增强for循环.
使用迭代器的时候,仅仅写泛型的时候就挺麻烦的,如果一个地方的泛型没有写正确就会报错,这种问题需要找好久
.

//方式4
		System.out.println("-------------------方式四: Map.entrySet()+迭代器 +-----------------------");
		Iterator<Entry<HashMap<String, Integer>, HashMap<String, Integer>>> iterator = out.entrySet()
				.iterator();
		while ( iterator.hasNext()) {
			Entry<HashMap<String, Integer>, HashMap<String, Integer>> outEntry = iterator.next();
			//内层键位hashMap继续用Map.entrySet()+迭代器 遍历
			HashMap<String, Integer> keyMap = outEntry.getKey();
			Iterator<Entry<String, Integer>> iteratorkeyMap = keyMap.entrySet().iterator();
			for ( ;iteratorkeyMap.hasNext();) {
				Entry<String, Integer> keyentry = iteratorkeyMap.next();
				System.out.println(keyentry.getKey()+"\t"+ keyentry.getValue());
			}
			
			//内层值位hashMap继续用迭代器+ Map.entrySet遍历
			HashMap<String, Integer> valueMap = outEntry.getValue();
			Set<Entry<String, Integer>> valueentrySet = valueMap.entrySet();
			Iterator<Entry<String, Integer>> iteratorvaluemap = valueentrySet.iterator();
			while(iteratorvaluemap.hasNext()){
				Entry<String, Integer> valueEntry = iteratorvaluemap.next();
				System.out.println(valueEntry.getKey()+"\t"+ valueEntry.getValue());
			}
		}
	}
}

遍历的时候,可以使用链式编程的地方,就使用链式编程,这样可以让程序看起来更简洁易懂,特别是嵌套集合遍历的时候,只是写泛型
就写到超出一行超出屏幕,看起来就头疼 .而且 map.keySet()获得的Set集合, Map.value()获得的colection集合,常常容易混淆,
还有那长长的泛型,真的看起来很冗长.那些每行都超出屏幕的代码,一眼看不到头,真的让人头痛.
其实我们知道这个集合里放的是什么类型就可以直接用链式编程获得最后的数据,这样就省去了中间的类型定义,还有那长长的泛型标记,
这样程序看起来也更简洁易懂. 这就好像我们很渴需要喝水的时候,我们需要的是快点喝水,并不会在乎我们拿到的杯子是
什么品牌,杯子的容量是多少,我们知道杯子里面是可以解渴的水,最直接的方式就是打开杯子喝水.