Map集合

      Map并没有继承Collection接口，可用于保存具有映射关系的数据，其提供的是key到value的映射。Map集合中保存的两组值，一组用于保存key，另一组用于保存value，key和value都可以是任何引用数据类型。Map集合中的key不允许重复，每一个key只能映射一个value

Map映射接口

public interface Map<K,V>

Map.Entry接口

public static interface Map.Entry<K,V>

      从定义来看可以发现Map.Entry接口是静态的，所以可以直接使用“外部类.内部类”的形式调用。Map.Entry封装了一个key-value。Map.Entry接口的方法如下所示

哈希映射类：HashMap类

    Map接口中有多个实现类，比较常用的是HashMap和TreeMap

public class HashMap<K,V>extends AbstractMap<K,V>implements Map<K,V>, Cloneable, Serializable

   HashMap类实现了Map集合，对于元素的添加和删除有着较高的效率，因为HashMap类是基于哈希表的Map接口的实现

• 向Map集合添加和获取元素的内容

import java.util.Map;
import java.util.HashMap;
public class Demo {
	public static void main(String[] args) {
		Map<Integer,String> map=new HashMap<Integer,String>(); //通过HashMap实例化Map
		map.put(1,"张三");	//添加内容
		map.put(2,"李四");	//添加内容
		map.put(3,"王五");	//添加内容
		map.put(4,"赵六");	//添加内容
		map.put(5,"孙七");	//添加内容
		System.out.println("获取内容："+map.get(5));	//获取内容
	}
}

获取内容：孙七

Map接口提供了put（K key,V value），可以向Map集合中添加key-value。因为Map集合中，key与value是一一对应的，所以可以通过指定key获取其对应的value值

• 获取Map集合中全部的key和value

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
public class Demo {
	public static void main(String[] args) {
		Map<Integer,String> map=new HashMap<Integer,String>(); //通过HashMap实例化Map
		map.put(1,"张三");	//添加内容
		map.put(2,"李四");	
		map.put(3,"王五");	
		map.put(4,"赵六");	
		map.put(5,"孙七");	
		
		Set<Integer> set = map.keySet();    //将集合中的全部key转换为Set集合
		Iterator<Integer> keys = set.iterator();    //实例化Iterator
		System.out.println("Map集合中的所有key如下：");
		while(keys.hasNext()){
			System.out.print(keys.next()+" ");
		}
		
		System.out.println();
		
		Collection<String> collection = map.values();   //将集合中全部的value转换为Collection集合
		Iterator<String> values = collection.iterator();  //实例化Iterator
		System.out.println("Map集合中的所有value如下：");
		while(values.hasNext()){
			System.out.print(values.next()+" ");
		}
	}
}

Map集合中的所有key如下：
1 2 3 4 5 
Map集合中的所有value如下：
张三 李四 王五 赵六 孙七 

      Map接口中提供了keySet()和values(),可以分贝获取Map集合中全部的key和value。但是不同的是，keySet()可以将Map结合中的所有值转换为Set集合，再使用Iterator输出；而values()返回的是Collection集合，同样使用Iterator输出。

     需要注意的是将Map集合转换为Collection集合时，需要保持泛型的一致！！！

• 使用Iterator输出Map集合

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Demo {
	public static void main(String[] args) {
		Map<Integer,String> map=new HashMap<Integer,String>(); //通过HashMap实例化Map
		map.put(1,"张三");	//添加内容
		map.put(2,"李四");	
		map.put(3,"王五");	
		map.put(4,"赵六");	
		map.put(5,"孙七");	
		
		Set<Entry<Integer,String>> set = map.entrySet();
		Iterator<Entry<Integer, String>> iterator = set.iterator();
		System.out.println("key-----value");
		while(iterator.hasNext()){    //判断是否还有元素
			Map.Entry<Integer, String> entry = iterator.next();    //实例化Map.entry
			System.out.println(entry.getKey()+"   :    "+entry.getValue());   //分离key和value
		}
	}
}

key-----value
1   :    张三
2   :    李四
3   :    王五
4   :    赵六
5   :    孙七

        Map与Collection集合不同，其本身并不能直接使用Iterator进行输出。因为Map集合使用的是二元偶对象，而Iterator一次只能输出一个值。如果想用迭代器输出，首先需要将Map实例通过entrySet()方法转换为Set集合；再由Set集合实例化Iterator，这时Iterator迭代器可以输出Map.Entry对象；最后通过Map.Entry的getKey()和getValue()方法分离Map集合的key和value

• 使用foreach输出Map集合

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Demo {
	public static void main(String[] args) {
		Map<Integer,String> map=new HashMap<Integer,String>(); //通过HashMap实例化Map
		map.put(1,"张三");	//添加内容
		map.put(2,"李四");	
		map.put(3,"王五");	
		map.put(4,"赵六");	
		map.put(5,"孙七");	
		
		System.out.println("key-----value");
		for (Map.Entry<Integer, String> mapEntry : map.entrySet()) {
			System.out.println(mapEntry.getKey()+"   :    "+mapEntry.getValue());
		}
	}
}

     使用foreach方式输出Map集合，可以不需要通过Set集合，只需将集合中的每一个元素用Map.Entry类型的对象接收，再使用getKey()和getValue()分离Map集合的key和value即可

有序树映射类：TreeMap

public class TreeMap<K,V>extends AbstractMap<K,V>implements NavigableMap<K,V>, Cloneable, Serializable

     TreeMap类不但实现了Map接口，还实现了SortedMap接口。因此TreeMap集合中的映射关系具有一定的顺序性。与HashMap相比，TreeMap集合在元素的添加、删除和定位映射性能较低。

     TreeMap集合主要是对所有的key进行排序，从而保证所有的key-value映射关系处于有序状态，默认为升序排序。也可以在创建TreeMap时，传入Comparator对象负责对TreeMap所有的key进行排序           如果想输出有序的HashMap集合时，也可以将HashMap集合中的内容添加到TreeMap集合中，再有其输出，哈哈哈-.-

• 输出有序的Map集合

import java.util.*;
public class Demo {
	public static void main(String[] args) {
		Map<String,String> hashMap=new HashMap<String,String>();	//通过HashMap实例化Map
		hashMap.put("zs","张三");	//添加内容
		hashMap.put("li","李四");	
		hashMap.put("ww","王五");	
		hashMap.put("zl","赵六");	
		hashMap.put("sq","孙七");	
		Set<Map.Entry<String,String>> hashSet = hashMap.entrySet();	//将Map集合转换为Set集合
		Iterator<Map.Entry<String,String>> hashIt = hashSet.iterator();	//实例化Iterator
		System.out.println("****使用HashMap输出：****");
		while (hashIt.hasNext())	//判断是否还有元素
		{
			Map.Entry<String,String> hashEntry = hashIt.next();	//实例化Map.Entry
		System.out.println(hashEntry.getKey()+"----"+hashEntry.getValue()); //分离key和value
		}
		Map<String,String> treeMap=new TreeMap<String,String>();
		treeMap.putAll(hashMap); //向TreeMap集合中添加HashMap集合
		Set<Map.Entry<String,String>> treeSet = treeMap.entrySet();	//将Map集合转换为Set集合
		Iterator<Map.Entry<String,String>> treeIt = treeSet.iterator();	//实例化Iterator
		System.out.println("\n****使用TreehMap输出：****");
		while (treeIt.hasNext())		//判断是否还有元素
		{
			Map.Entry<String,String> treeEntry =treeIt.next();	//实例化Map.Entry
			System.out.println(treeEntry.getKey()+"----"+treeEntry.getValue()); //分离key和value
		}
	}
}

****使用HashMap输出：****
ww----王五
zl----赵六
zs----张三
li----李四
sq----孙七

****使用TreehMap输出：****
li----李四
sq----孙七
ww----王五
zl----赵六
zs----张三

       在这个程序中key值是按照字母的顺序排序的，因为String类已经实现了Comparable接口，所以程序可以运行；如果使用的是自定义类，则该类需要实现Comparable接口，否则会抛出类型转换异常，切记！！！

集合总结

1. Collection是集合类的基本接口，其主要的子接口有List和Set，而Map不是其子接口。Collection接口声明所有集合类的核心方法。一般情况下都不会使用Collection接口，而是使用其子类List和Set集合。
2. List是有序的Collection，使用List接口可以精确地控制每个元素插入的位置，也可以通过索引来访问List中的元素。List接口常用的实现类有ArrayList和LinkedList。List集合允许存放重复的元素。
3. Set是一个不包含重复元素的Collection，Set允许包含null元素，但不能包含重复的元素。一般需要重写类的equals()和hashCode()方法来区别Set集合中元素是否相同。
4. Set接口常用的子类有HashSet和TreeSet，其中HashSet类是按照哈希算法来存取集合中的元素的，其存取的效率高。HashSet类是无序存放元素的，而TreeSet是有序存放元素的，但需要使用Comparable进行排序操作。
5. Map并没有继承Collection接口，可用于保存具有映射关系的数据，其提供的是key到value的映射。
6. Map接口的常用实现类有HashMap和TreeMap。HashMap类是基于哈希表的Map接口的实现，对于元素的添加和删除有着较高的效率。TreeMap集合主要是对所有的key进行排序，从而保证所有的key-value映射关系处于有序状态。TreeMap集合在元素的添加、删除和定位映射性能较低