【JavaSE筆記】集合(五)_Map

本期知識點：
Map及其相關
Collections集合工具類

1.Map

a.概述

將鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。

b.Map和Collection的區別?

i.Map集合，是一種鍵值對的一種映射關係。存儲的是鍵值對的形式的元素。鍵是唯一的，值可以重複。

HashMap TreeMap 子實現類

ii.Collection集合是集合框架的頂層接口。存儲的是單獨出現的元素。子接口List元素可以重複，子接口Set元素唯一。

ArrayList Vector LinkedList 子實現類

c.Map接口功能

A:添加功能：

V put(K key,V value) 添加元素(鍵和值的具體元素)

其他用法:如果鍵是第一次存儲的時候,返回值null(小細節) 如果鍵已經存在,再次存儲的時候將第一次的值返回,並且後面的值覆蓋掉前面的值

B:刪除功能：

void clear() 從此映射中移除所有映射關係(移出所有的鍵和值)

V remove(Object key) 刪除鍵,返回值

C:判斷功能：

boolean containsKey(Object key) 判斷當前Map集合中是否存在key:鍵

boolean containsValue(Object value)判斷當前Map姐中是否存在value:值

D:獲取功能：

V get(Object key) 返回指定鍵所映射的值

Set<K> keySet() 獲取所有的鍵的集合

Collection<V> values() 獲取所有的值的集合

Set<Map.Entry<K,V>>

E:長度功能：

int size()

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class 獲取功能 {
	public static void main(String[] args) {
		//創建Map集合對象
		Map<String, String> m = new HashMap<String,String>();
		//添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		
		//V get(Object key)返回指定鍵所映射的值
		String a = m.get("Ash");
		System.out.println("Values:"+a);
		
		//Set<K> keySet():獲取所有的鍵的集合
		Set<String> k = m.keySet();
		System.out.println("AllKey:"+k);
		
		//Collection<V> values():獲取所有的值的集合 
		Collection<String> v =m.values();
		System.out.println("AllValues:"+v);
	}
}
//out:
//Values:Thermite
//AllKey:[Blitz, Twitch, Ash, Glaz]
//AllValues:[IQ, Montagne , Thermite, Fuze]

import java.util.HashMap;
import java.util.Map;

public class 添加刪除長度功能 {
	public static void main(String[] args) {
		Map<String,String> m = new HashMap<String,String>();
		//給集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//void clear() 移除所有映射關係
//		m.clear();
//		System.out.println(m);//{}
		
		//V remove(Object key):刪除鍵,返回值
		System.out.println(m.remove("Ash"));//Thermite
		System.out.println(m.remove("Glaz"));//Fuze
		System.out.println(m);//{Blitz=IQ, Twitch=Montagne }
		
		//int size();
		System.out.println(m.size());//2
	}
}

d.Map集合的遍歷

i:鍵找值

1):獲取所有鍵的集合

2):遍歷鍵的集合,得到每一個鍵

3):根據鍵到集合中去找值

ii:鍵值對對象找鍵和值

1):獲取所有的鍵值對對象的集合

2):遍歷鍵值對對象的集合，獲取每一個鍵值對對象

3):根據鍵值對對象去獲取鍵和值

4):接口 Map.Entry<K,V>:(正在封閉接口：Map<K,V>)

public static interface Map.Entry<K,V>

映射項（鍵-值對）。Map.entrySet 方法返回映射的 collection 視圖，其中的元素屬於此類。獲得映射項引用的唯一方法是通過此 collection 視圖的迭代器來實現。

方法：

boolean equals(Object o) 比較指定對象與此項的相等性。如果給定對象也是一個映射項，並且兩個項表示相同的映射關係，則返回 true。

K getKey() 與此項對應的鍵

V getValue() 返回與此項對應的值。如果已經從底層映射中移除了映射關係（通過迭代器的 remove 操作），則此調用的結果是不確定的。

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

public class Map集合的遍歷_鍵找值 {
	public static void main(String[] args) {
		//創建Map集合對象
		Map<String, String> m = new HashMap<String,String>();
		//給集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//獲取所有鍵的值
		Set<String> s = m.keySet();
		//遍歷所有鍵的集合
		for (String k : s) {
			String v = m.get(k);
			System.out.println(k+"---"+v);
		}
	}
}
//out:
//	Blitz---IQ
//	Twitch---Montagne 
//	Ash---Thermite
//	Glaz---Fuze

ii.

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

public class Map集合的遍歷_鍵值對對象找鍵和值 {
	public static void main(String[] args) {
		//創建Map集合對象
		Map<String, String> m = new HashMap<String,String>();
		//給集合添加元素
		m.put("Ash", "Thermite");
		m.put("Twitch", "Montagne ");
		m.put("Glaz", "Fuze");
		m.put("Blitz", "IQ");
		//獲取 鍵值對 對象的集合
		Set<Entry<String, String>> s = m.entrySet();
		//遍歷 鍵值對 對象的集合
		for (Entry<String, String> me : s) {
			//鍵值對 對象中有兩個方法 關於 Key 和 Values
			//K getKey():獲取鍵
			//V getValue():獲取值
			String key = me.getKey();
			String values = me.getValue();
			System.out.println(key+"---"+values);
		}
	}
}
//out:
//	Blitz---IQ
//	Twitch---Montagne 
//	Ash---Thermite
//	Glaz---Fuze

2.Map集合體系圖：

3.HashMap的嵌套

a.ArrayList-HashMap

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

public class ArrayList_HashMap {
	public static void main(String[] args) {
		ArrayList<HashMap<String, Integer>> a = new ArrayList<HashMap<String, Integer>>();
		
		HashMap<String, Integer> m = new HashMap<String,Integer>();
		
		m.put("Ash", 22);
		m.put("Fuze", 23);
		m.put("Glaz", 22);	
		
		a.add(m);
		//ArrayList迭代器
		Iterator<HashMap<String, Integer>> it = a.iterator();
		while(it.hasNext()){
			HashMap<String, Integer> n = it.next();
			Set<String> keySet = n.keySet();
			for (String key : keySet) {
				Integer values = n.get(key);
				System.out.println(key+"---"+values);
			}
		}
		System.out.println("-----------");
		//增強for
		for (HashMap<String, Integer> hm : a) {
			Set<String> keySet = hm.keySet();
			for (String k : keySet) {
				Integer values = hm.get(k);
				System.out.println(k+"---"+values);
			}
		}
	}
}
//out:
//	Ash---22
//	Fuze---23
//	Glaz---22
//	-----------
//	Ash---22
//	Fuze---23
//	Glaz---22

b.HashMap-HashMap

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

public class HashMap_HashMap {
	public static void main(String[] args) {
		HashMap<String, HashMap<String, Integer>> hm = new HashMap<String, HashMap<String, Integer>>();
		
		HashMap<String, Integer> m1 = new HashMap<String, Integer>();
		
		m1.put("Tom", 20);
		m1.put("Peter", 21);
		
		hm.put("自動化", m1);
		HashMap<String, Integer> m2 = new HashMap<String, Integer>();
		
		m2.put("Ash", 22);
		m2.put("Rook", 21);
		
		hm.put("計算機", m2);
		//遍歷
		Set<String> hms = hm.keySet();
		for (String hmk : hms) {
			System.out.println(hmk);
			HashMap<String, Integer> hmv = hm.get(hmk);
			Set<String> hmss = hmv.keySet();
			for (String hmkk : hmss) {
				Integer hmvv = hmv.get(hmkk);
				System.out.println(hmkk+"---"+hmvv);
			}
		}
		}
}
//out:
//	自動化
//	Tom---20
//	Peter---21
//	計算機
//	Ash---22
//	Rook---21

c.HashMap-ArrayList

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class HashMap_ArrayList {
	public static void main(String[] args) {
		HashMap<String, ArrayList<String>> m = new HashMap<String, ArrayList<String>>();
		ArrayList<String> a = new ArrayList<String>();
		a.add("Ash");
		a.add("Glaz");
		a.add("Fuze");
		
		m.put("進攻方", a);
		
		Set<String> keySet = m.keySet();
		for (String key : keySet) {
			System.out.println(key);
			ArrayList<String> values = m.get(key);
			for (String vkey : values) {
				System.out.println(vkey);
			}
		}
	}
}
//out:
//	進攻方
//	Ash
//	Glaz
//	Fuze

d.Hashtable和HashMap的區別:

HashMap集合:允許有null鍵和null值,從線程的角度考慮:他是一個線程不安全,不同步,執行效率高

Hashtable集合:不允許有null鍵,從線程的角度考慮:他是一個線程安全的,同步,效率低

4.TreeMap

TreeMap:基於紅黑樹結果

兩種排序:自然排序,比較器排序

import java.util.Set;
import java.util.TreeMap;

public class TreeMapDemo {
	public static void main(String[] args) {
		//創建TreeMap集合對象
		TreeMap<String, Integer> t = new TreeMap<String, Integer>();
		//添加元素
		t.put("Ash", 21);
		t.put("Fuze", 21);
		t.put("Glaz", 21);
		t.put("Tom", 21);
		//遍歷
		Set<String> keySet = t.keySet();
		for (String k : keySet) {
			Integer v = t.get(k);
			System.out.println(k+"---"+v);
		}
	}
}
//out:
//	Ash---21
//	Fuze---21
//	Glaz---21
//	Tom---21

public class Student {
	private String name;
	private int age;
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.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;
	}
	
}
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class TreeMapStudentDemo {
	public static void main(String[] args) {
		TreeMap<Student, String> t = new TreeMap<Student, String>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				//按照年齡大小排序
				int a = o1.getAge()-o2.getAge();
				//按照名字內容
				int b = a == 0? o2.getName().compareTo(o1.getName()):a;
				return b;
			}
		});
		//創建學生對象
		Student s1 = new Student("Tom",21);
		Student s2 = new Student("Ash",22);
		Student s3 = new Student("Peter",20);
		Student s4 = new Student("Rush",21);
		//添加
		t.put(s1, "自動化");
		t.put(s2, "自動化");
		t.put(s3, "計算機");
		t.put(s4, "計算機");
		
		//獲取所有的鍵的集合
		Set<Student> keySet = t.keySet();
		for (Student k : keySet) {
			String v = t.get(k);
			System.out.println(k.getName()+"---"+k.getAge()+"---"+v);
		}
		
	}
}
//out:
//	Peter---20---計算機
//	Tom---21---自動化
//	Rush---21---計算機
//	Ash---22---自動化

5.Collections

a.概述:

對集合操作的工具類

b.Collections和Collection的區別?

Collection:集合:頂層次的一個根接口,有兩個子接口:List,Set

Collections:對集合操作的工具類,具體的類:它針對集合進程操作!

c.方法：

public static <T> void sort(List<T> list) 默認自然排序:將集合中的元素升序排序

public static <T> int binarySearch(List> list,T key) 二分查找搜索法:key:查找的元素

public static void reverse(List list) 反轉功能

public static void shuffle(List<?> list) 隨機置換,打亂順序

import java.util.ArrayList;
import java.util.Collections;

public class Demo01 {
	public static void main(String[] args) {
		ArrayList<Integer> a = new ArrayList<Integer>();
		//添加元素:
		a.add(20) ;
		a.add(17);
		a.add(19) ;
		a.add(18) ;
		a.add(24) ;
		a.add(23) ;
		a.add(22) ;
		System.out.println(a);
//		public static <T> void sort(List<T> list)		
//		默認自然排序:將集合中的元素升序排序
		Collections.sort(a);
		System.out.println(a);
//		public static <T> int binarySearch(List> list,T key):二分查找搜索法:key:查找的元素
		int index = Collections.binarySearch(a, 20);
		System.out.println(index);
//		public static void reverse(List list):反轉功能
		Collections.reverse(a);
		System.out.println(a);
//		public static void shuffle(List<?> list):隨機置換,打亂順序
		Collections.shuffle(a);		
		System.out.println(a);
	}
}

追雲的帆

發佈了51 篇原創文章 · 獲贊 15 · 訪問量 1萬+

私信關注

【JavaSE筆記】集合(五)_Map

1.Map

a.概述

b.Map和Collection的區別?

c.Map接口功能

A:添加功能：

B:刪除功能：

C:判斷功能：

D:獲取功能：

E:長度功能：

d.Map集合的遍歷

i:鍵找值

ii:鍵值對對象找鍵和值

2.Map集合體系圖：

3.HashMap的嵌套

a.ArrayList-HashMap

b.HashMap-HashMap

c.HashMap-ArrayList

d.Hashtable和HashMap的區別:

4.TreeMap

5.Collections

a.概述:

b.Collections和Collection的區別?

c.方法：

Python 潮流週刊#52：Python 處理 Excel 的資源

【JavaSE筆記】集合(三)_Set

【JavaSE筆記】IO(一)異常

【JavaSE筆記】網絡基礎&網絡編程

【JavaSE筆記】Java常用類及其方法（十）_Math

【JavaSE筆記】集合(二)_泛型

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結