24.Map接口：

 Map接口定义了存储“键（key）-值（value）映射对”的方法，Map中不能有重复的“键”，

 Map实现类中储存的”键-值“映射对是通过键来唯一标识的，Map底层的”键“使用Set来存放的，

 所以Map中的映射对的”键”对应的类必须重写hashCode()和equals()方法， 

 常用String作为Map的“键”。

 Map的添加、删除操作：

 · Object put(Object key, Object value): 将相互关联的“键-值”存入该映像，如果该关键字已经存在，

   那么与此关键字相关的新值将取代就值，否则返回null。

 · Object remove(Object key): 根据指定的键，把“键-值”从Map中移除。

 · void putAll(Map t): 将来自特定映像的所有元素添加到该映像。

 · Void clear(): 从映像中删除所有的映像。

 Map中元素的查询操作：

 · Object get(Object key): 获得与关键字key相关的值，并且返回与关键字key相关的对象，

   如果未找到，返回null。

 · boolean containsKey(Object key): 判断映像中是否存在关键字key。

 · Boolean containsValue(Object value): 判断映像中是否存在value。

 · int size(): 返回当前映像中的数量。

 · boolean isEmpty(): 判断映像是否为空。

 Map中元素视图方法：

 · Set keySet(): 返回映像中所有关键字的视图set集，同时还可以从视图中删除“键-值”对，

   但不能添加“键-值”对。

 · Collectio values(): 返回映像中所有值得视图集，同时还可以从视图中删除“键-值”对，

   但不能添加“键-值”对。

 · Set entrySet(): 返回映像中的“键-值”对，同时还可以以从视图中删除“键-值”对，

   但不能添加“键-值”对。

1>实现类HashMap：

 HashMap是使用频率最高的一个容器，它内部对“键”用Set进行三列存放，所以根据“键”去取“值”得效率高，

 并且它允许使用null 值和null键，但不能保证映射的书序。

下面是HashMap相关用法的例子：

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

public class HashMapTest {

	public static void main(String[] args) {
		// 声明一个HashMap对象
		HashMap<String, String> hmp = new HashMap<String, String>();
		
		// 向hmp中添加“key - value”对
		hmp.put("1", "d");
		hmp.put("0", "c");
		hmp.put("3", "a");
		hmp.put("2", "b");
		hmp.put("5", "e");
		hmp.put("4", "g");
		
		// 输出“key - value”对
		System.out.println("HashMap: \n<K, V>");
		System.out.println("\n显示“key-value”对： ");
		System.out.println(hmp);
		
		// 删除“key - value”对
		hmp.remove("3");
		hmp.remove("2");
		System.out.println("\n显示删除“key-value“后的”键-值“对： ");
		System.out.println(hmp);
		
		//由key获取value
		System.out.println("\n由key取得对应value： ");
		System.out.println("4=" + hmp.get("4"));
		
		// 获取全部键值，它的返回类型是Set
		Set<String> set = hmp.keySet();
		
		//判断是否存在关键字key
		System.out.println("\n判断是否存在指定key：");
		System.out.println("是否存在key7：" + hmp.containsKey("7"));
		
		//判断是否存在指定value
		System.out.println("\n判断是否存在指定value：");
		System.out.println("是否存在key4"+hmp.containsValue("g"));
		
		//判断容器是否为空
		System.out.println("\n容器是否为空：" + hmp.isEmpty());
		
		//输出容器的容量
		System.out.println("\n输出容器的容量：" + hmp.size());
		
		// 生成一个 迭代器
		Iterator<String> it = set.iterator();
		// 使用键生成的迭代器输出所有”键-值“对的值
		System.out.println("\n输出值： ");
		while (it.hasNext()) {
			System.out.print(hmp.get(it.next()) + ";");
		}
	}
}

输出结果：

HashMap: 

<K, V>

显示“key-value”对： 

{3=a, 2=b, 1=d, 0=c, 5=e, 4=g}

显示删除“key-value“后的”键-值“对： 

{1=d, 0=c, 5=e, 4=g}

由key取得对应value： 

4=g

判断是否存在指定key：

是否存在key7：false

判断是否存在指定value：

是否存在key4：true

容器是否为空：false

输出容器的容量：4

输出值： 

d;c;e;g;

可以看出“键 - 值”对的输出顺序和输出的顺序是不同的。

2>实现类LinkedHashMap：

 LilkedHashMap类是hashMap的子类，它可以依照插入的书序来排列元素，增、删、改效率比较高。

下面为LinkedHashMap的例子：

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

 public class HashMapTest {

	public static void main(String[] args) {
		//声明一个LinkedHashMap对象
		Map<Integer, String> lhmp = newLinkedHashMap
　　　<Integer, String>();
		//想lhmp中添加“键 - 值”对
		lhmp.put(1, "a");
		lhmp.put(0, "c");
		lhmp.put(3, "a");
		lhmp.put(2, "b");
		//输出“键 - 值”对
		System.out.println("LinkedHashMap: \n<K, V>");
		System.out.println(lhmp);
		//获取全部键值，它的返回类型是Set
		Set<Integer> set = lhmp.keySet();
		//生成一个 迭代器
		Iterator<Integer> it = set.iterator();
		//使用键生成的迭代器输出所有”键-值“对的值
		System.out.println("<V>");
		while (it.hasNext()) {
			System.out.print(lhmp.get(it.next()) + ";");
		}
	}
 }

输出结果：

 <K, V>

 {1=a, 0=c, 3=a, 2=b}

 <V>

 a;c;a;b;

 可以看出“键 - 值”的输入顺序和输出顺序是完全对应的。如果在映射中重新插入键，则插入书序不受影响。

3>实现类TreeMap：

 存放入TreeMap中的“键 - 值”对的“键”必须是可排序的。

下面通过例子演示TreeMap的相关用法：

import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 public class TreeMapTest {
	public static void main(String[] args) {
		//声明一个TreeMap对象
		Map<String, String> tmp = new TreeMap<String, String>();	
		//向lhmp中添加“键 - 值”对
		lhmp.put(1, "a");
		lhmp.put(0, "c");
		lhmp.put(3, "a");
		lhmp.put(2, "b");
		//输出“键 - 值”对
        System.out.println("TreeMap: \n<K, V>");		   
        System.out.println(tmp);
　　　    System.out.println("输出容器的大小: " + tmp.size());
		//获取全部键值，它的返回类型是Set
		Set<String> set = tmp.keySet();
		//生成一个 迭代器
		Iterator<String> it = set.iterator();
		//使用键生成的迭代器输出所有”键-值“对的值
		System.out.println("<V>");
		while (it.hasNext()) {
			System.out.print(tmp.get(it.next()) + ";");
		}
	}
 }

输出结果：

LinkedHashMap: 

<K, V>

{0=c, 1=a, 2=b, 3=a}

输出容器的大小: 4

<V>

c;a;b;a;

在TreeMap中“键”必须是可排序的，在内部存储时会按“键”的序列存储，输出相同。

4>实现类Properties：

 Properties类表示了持久的属性集，它可以保存在流中或从流中加载。且其存放的“键 - 值”对都是字符串，

 在存取时应使用setProperties(String key, String value)方法和getProperty(String key)方法。

 下面是Properties类的演示例子：

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Properties;

 public class TreeMapTest {

	public static void main(String[] args) {
         //获取文件并读入到输入流
		InputStream is = (InputStream) Thread.currentThread()
				.getContextClassLoader()
				.getResourceAsStream("config.properties");
		// 创建属性集对象
		Properties prop = new Properties();
		try {
			// 从流中加载数据
			prop.load(is);
		} catch (IOException e) {
			e.printStackTrace();
		}		
        // 获取name属性
		String name = prop.getProperty("name");
		System.out.println("name = " + name);
		//获取password属性
		String pwd = prop.getProperty("password");
		System.out.println("password = " + pwd);
	}
 } 

输出结果：

 name = spilit

 password = abc123

 在src中建立Fiel文档config.properties：

 #Key=value

 name=spilit

 password=abc123