Collection集合的特點是每次進行單個物件的儲存，如果現在要進行一對物件的儲存，就只能用Map集合來完成，即Map集合中會一次性儲存兩個物件，且這兩個物件的關係：key = value結構。這種結構的最大特點是可以通過key找到對應的value內容。
1.Map介面
Map介面定義：
public interface Map<K,V>

在Map介面中有如下常用方法：

Map本身是一個介面，要使用Map需要通過子類進行物件例項化。Map介面的常用子類有如下四個：HashMap、HashTable、TreeMap、ConcurrentHashMap。
2.HashMap子類

如：基本操作

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(2, "B");
		map.put(3, "C");
		System.out.println(map);
		System.out.println(map.get(2));  //根據key取得value
		System.out.println(map.get(10));  //找不到返回null
		
		//取得Map中所有key資訊
		Set<Integer> set = map.keySet();
		Iterator<Integer> iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}
 

注意：
(1)key值不允許重複，如果重複，則會把對應value值更新；
(2)key和value都允許為null，key為null有且只有一個。
HashMap原理：在資料量小的(JDK1.8後閾值為8)時候，HashMap是按照連結串列的模式儲存的；當資料量變大之後，為了進行快速查詢，會將這個連結串列變為紅黑樹(均衡二叉樹)來進行儲存，用hash來進行查詢。
3.HashTable子類

如：HashTable使用

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new Hashtable<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(3, "C");
		map.put(2, "B");
		System.out.println(map);
	}
}
 

注意：key、value均不允許為null。

4.ConcurrentHashMap子類
ConcurrentHashMap的特點：Hashtable的執行緒安全性 + HashMap的高效能。在使用ConcurrentHashMap處理的時候，既可以保證多個執行緒更新資料的同步，又可以保證很高效的查詢速度。ConcurrentHashMap不允許key和value為null。
高效能：
(1)資料更新的時候只鎖對應區域(桶)，而其他區域的訪問不受影響；
(2)在鎖的區域使用讀寫鎖，讀非同步而寫同步，即便在同一個桶中，資料讀取依然不受影響。

如：使用ConcurrentHashMap

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new ConcurrentHashMap<>();
		map.put(1, "A");
		map.put(1, "A+");
		map.put(3, "C");
		map.put(2, "B");
		System.out.println(map);
	}
}
 

5.Map集合使用Iterator輸出
(1)Iterator只存在於Collection及其子類中；
(2)把Map集合轉為Set集合：public Set<Map.Entry<K, V>> entrySet();
(3)set.iterator;

如：通過Iterator輸出Map集合

public class Test {
	public static void main(String[] args) {
		Map<Integer, String> map = new HashMap<>();
		map.put(1, "A");
		map.put(2, "B");
		map.put(3, "C");
		// 1.將Map集合轉為Set集合
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		// 2.獲取Iterator物件
		Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
		// 3.輸出
		while (iterator.hasNext()) {
			// 4.取出每一個Map.Entry物件
			Map.Entry<Integer, String> entry = iterator.next();
			// 5.獲取key和value
			System.out.println(entry.getKey() + " = " + entry.getValue());
		}
	}
}

6.關於Map中的key
在Map集合中如果使用自定義類作為key，一定要覆寫Object類中的hashCode()與equals()方法。

如：HashMap使用自定義類作為key

class Person{
	private String name;
	private int age;
	public Person(int age,String name) {
		this.age = age;
		this.name = name;
	}
	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 String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}
public class Test{
	public static void main(String[] args) {
		Map<Person, String> map = new HashMap<>();
		map.put(new Person(10, "張三"), "ZS");
		System.out.println(map.get(new Person(10, "張三")));
	}
}

7.TreeMap子類
TreeMap是一個可以排序的Map子類，它是按照key的內容排序的。

如：TreeMap的使用

public class Test{
	public static void main(String[] args) {
		Map<Integer, String> map = new TreeMap<>();
		map.put(2, "B");
		map.put(1, "A");
		map.put(3, "C");
		System.out.println(map);  //輸出：{1=A, 2=B, 3=C}
	}
}

如：TreeMap使用自定義類作為key

class Person implements Comparable<Person>{
	private String name;
	private int age;
	public Person(int age,String name) {
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", 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 int compareTo(Person o) {
		if(this.age > o.age) {
			return 1;
		}else if(this.age < o.age) {
			return -1;
		}else {
			return this.name.compareTo(o.name);
		}
		
	}
}
public class Test{
	public static void main(String[] args) {
		Map<Person, String> map = new TreeMap<>();
		map.put(new Person(10, "張三"), "ZS");
		System.out.println(map.get(new Person(10, "張三")));
	}
}