Java學習Map接口
阿新 • • 發佈：2018-04-18
可變參數 object 多個參數 ride string類 brush xxx ger arrays
Map集合和Collection集合是完全分開的
Collection中的集合，元素是孤立存在的，向集合中存儲元素采用一個一個元素的方式存儲 單列集合
Map中的集合，元素是成對存在的，每個元素都是由鍵與值兩部分組成的，通過鍵找對應的值 雙列集合
Map中的集合不能包含重復的鍵，值可以重復，每個鍵只能對應一個值
Map中常用的集合為HashMap集合、LinkedHashMap集合
HashMap集合
HashMap<K,V>：存儲數據采用的哈希表結構，元素的存取順序不能保證一致。由於要保證鍵的唯一、不重復，需要重寫鍵的hashCode()方法、equals()方法。
LinkedHashMap集合
LinkedHashMap<K,V>：HashMap下有個子類LinkedHashMap，存儲數據采用的哈希表結構+鏈表結構。通過鏈表結構可以保證元素的存取順序一致；通過哈希表結構可以保證的鍵的唯一、不重復，需要重寫鍵的hashCode()方法、equals()方法。
註意：Map接口中的集合都有兩個泛型變量<K,V>,在使用時，要為兩個泛型變量賦予數據類型。兩個泛型變量<K,V>的數據類型可以相同，也可以不同。
Map接口中常用的方法
package com.oracle.demo1;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
put();
System.out.println("======================");
get();
System.out.println("======================");
delete();
System.out.println("======================");
bianli();
System.out.println("======================");
bianli2();
}
/*
* 向集合中添加元素 V put(K key, V value) 將指定的值與此映射中的指定鍵關聯（可選操作）。
* 如果集合中存儲之前沒有這個鍵，那麽返回null 如果存儲之前集合中存在這個鍵，那麽會替換到這個鍵所對應的值， 並且返回替換前這個鍵所對應的值
*/
public static void put() {
Map<Integer, String> m = new HashMap<Integer, String>();
String v1 = m.put(1, "張三");
String v2 = m.put(2, "李四");
String v3 = m.put(3, "王五");
String v4 = m.put(3, "趙六");
System.out.println(v1 + "---" + v2 + "---" + v4);
System.out.println(m);
}
/*
* 獲取Map集合中指定鍵的值 V get(Object key) 返回指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則返回 null。
*/
public static void get() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "張三");
m.put(2, "李四");
m.put(3, "王五");
String v = m.get(1);
System.out.println(v);
}
/*
* 刪除元素 V remove(Object key) 如果存在一個鍵的映射關系，則將其從此映射中移除（可選操作）。
* 1、刪除傳入的鍵以及對應的值
* 2、返回你要刪除的鍵對應的值
*/
public static void delete() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "張三");
m.put(2, "李四");
m.put(3, "王五");
System.out.println(m);
String v = m.remove(3);
System.out.println(v);
System.out.println(m);
}
/*
* 遍歷Map集合 鍵找值
* 1、獲取你的所有鍵所對應的set集合
* 2、遍歷你的set集合，然後取對應的values值
*/
public static void bianli() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "張三");
m.put(2, "李四");
m.put(3, "王五");
// 1、獲取裝有鍵的set集合
// Set<Integer> s=m.keySet();
// 2、增強for遍歷set集合
for (Integer i : m.keySet()) {
// 獲取鍵
int key = i;
// 獲取值
String values = m.get(key);
System.out.println(key + "===" + values);
}
System.out.println("================");
// Iterator遍歷
Set<Integer> set = m.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
int key = it.next();
String values = m.get(key);
System.out.println(key + "===" + values);
}
}
/*
* 通過映射關系遍歷Map
* 獲取Map集合中，所有的鍵值對(Entry)對象，以Set集合形式返回。
* 通過增強for循環和Iterator遍歷set集合獲取Map中的數據
*/
public static void bianli2() {
Map<Integer, String> m = new HashMap<Integer, String>();
m.put(1, "張三");
m.put(2, "李四");
m.put(3, "王五");
// 1、先得到set集合
// Set<Map.Entry<Integer, String>> set = m.entrySet();
// Iterator<Map.Entry<Integer, String>> it = set.iterator();
// while (it.hasNext()) {
// Map.Entry<Integer, String> map = it.next();
// int k = map.getKey();
// String v = map.getValue();
// System.out.println(k + "======" + v);
// }
// 增強for遍歷集合
for (Map.Entry<Integer, String> map : m.entrySet()) {
int k = map.getKey();
String v = map.getValue();
System.out.println(k + "======" + v);
}
}
}
Map中鍵找值的方式
鍵找值方式：即通過元素中的鍵，獲取鍵所對應的值
操作步驟與圖解：
1.獲取Map集合中所有的鍵，由於鍵是唯一的，所以返回一個Set集合存儲所有的鍵
2.遍歷鍵的Set集合，得到每一個鍵
3.根據鍵，獲取鍵所對應的值
Entry鍵值對
Entry將鍵值對的對應關系封裝成了對象。即鍵值對對象，這樣我們在遍歷Map集合時，就可以從每一個鍵值對（Entry）對象中獲取對應的鍵與對應的值。
Entry是Map接口中提供的一個靜態內部嵌套接口，可以直接用類名調用
getKey()方法：獲取Entry對象中的鍵
getValue()方法：獲取Entry對象中的值
entrySet()方法：用於返回Map集合中所有的鍵值對(Entry)對象，以Set集合形式返回
Map中遍歷鍵值對的方式
鍵值對方式：即通過集合中每個鍵值對(Entry)對象，獲取鍵值對(Entry)對象中的鍵與值。
操作步驟與圖解：
1.獲取Map集合中，所有的鍵值對(Entry)對象，以Set集合形式返回。
2.遍歷包含鍵值對(Entry)對象的Set集合，得到每一個鍵值對(Entry)對象
3.通過鍵值對(Entry)對象，獲取Entry對象中的鍵與值。
HashMap存儲自定義類型鍵值
package com.oracle.demo1;
public class Person {
String name;
int 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;
}
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return name + "----" + 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;
}
}
package com.oracle.demo1;
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
key();
System.out.println("=============");
values();
}
public static void key() {
//當自定義類作為鍵時，由於類中沒有重寫hashCode和equals方法
//所以輸入的數據中盡管有重復的數據，也會存進去
//由於Java中對鍵值對的規範，鍵不能重復，
//所以需要在自定義類中重寫hashCode和equals方法
HashMap<Person, String> hs = new HashMap<Person, String>();
hs.put(new Person("張三", 18), "java");
hs.put(new Person("李四", 34), "php");
hs.put(new Person("張三", 18), "python");
hs.put(new Person("王五", 18), "java");
System.out.println(hs);
}
public static void values() {
//String類作為鍵，由於String中重寫了hashCode和equals方法
//所以當輸入的鍵有重復數據時，會自動識別，保證鍵的唯一性
HashMap<String, Person> hs = new HashMap<String, Person>();
hs.put("java", new Person("張三", 18));
hs.put("php", new Person("李四", 34));
hs.put("python", new Person("張三", 18));
hs.put("java", new Person("王五", 18));
System.out.println(hs);
}
}
當給HashMap中存放自定義對象時，如果自定義對象作為key存在，這時要保證對象唯一，必須復寫對象的hashCode和equals方法
如果要保證map中存放的key和取出的順序一致，可以使用LinkedHashMap集合來存放。
package com.oracle.demo1;
import java.util.HashMap;
import java.util.LinkedHashMap;
public class LinkedHashMapDemo {
public static void main(String[] args) {
//LinkedHashMap是有序的，就是怎麽存怎麽取
LinkedHashMap<String,String> lhm=new LinkedHashMap<String,String>();
lhm.put("abc", "張三");
lhm.put("java", "李四");
lhm.put("aac", "王五");
lhm.put("gdr", "張三");
System.out.println(lhm);
//HashMap不是有序的，不一定怎麽存怎麽取
HashMap<String,String> hm=new HashMap<String,String>();
hm.put("abc", "張三");
hm.put("java", "李四");
hm.put("aac", "王五");
hm.put("gdr", "張三");
System.out.println(hm);
}
}
靜態導入
在導包的過程中我們可以直接導入靜態部分，這樣某個類的靜態成員就可以直接使用了。在源碼中經常會出現靜態導入。
靜態導入格式：
import static XXX.YYY; 導入後YYY可直接使用。
package com.oracle.demo2;
import static java.lang.System.out;
import static java.util.Arrays.sort;
public class StsticDemo {
public static void main(String[] args) {
out.println("這是靜態導入");
int[] arr = { 2, 4, 6, 3, 6, 1, 8 };
sort(arr);
for (int i : arr) {
out.println(i);
}
}
}
可變參數
在JDK1.5之後，如果我們定義一個方法需要接受多個參數，並且多個參數類型一致
package com.oracle.demo2;
public class Demo {
public static void main(String[] args) {
System.out.println(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
}
// 可變參數 參數類型相同，但是參數個數不定
// int ...a實際上是一個數組
//註：1、如果在一個參數列表中需要傳入多種類型，則可變列表必須放到最後
// 如：public static void add(String str,int ...a){}
// 2、在一個參數列表中只能有一個可變參數
public static int add(int... a) {
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum = sum + a[i];
}
return sum;
}
// public static int add(int a, int b) {
// return a + b;
// }
}
Collections集合工具類
常用方法
package com.oracle.demo2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(4);
list.add(2);
list.add(3);
list.add(9);
list.add(7);
System.out.println(list);
System.out.println("=====================");
// 將集合中元素的順序打亂
// 該方法返回值是靜態的，所以直接用類名調用方法
//該方法僅限於list集合
Collections.shuffle(list);
System.out.println(list);
System.out.println("=====================");
Collections.sort(list);
System.out.println(list);
}
}
集合嵌套
所謂的集合嵌套就是集合內容又是集合，如Collection集合嵌套、Collection集合與Map集合相互嵌套、Map集合嵌套。
1、 ArrayList嵌套 ArrayList
ArrayList< ArrayList<String> >
Collection< ArrayList<Integer> >
2、 Map嵌套 ArrayList
HashMap<String, ArrayList<Person>>
ArrayList< HashMap<String, String>>
3、 Map集合嵌套
HashMap<String, HashMap<String,String>>
HashMap<String, HashMap<Person,String>>
package com.oracle.demo2;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//集合中Map嵌套Map 的存和取
public class MapQianTao {
public static void main(String[] args) {
// 集合嵌套
HashMap<String, HashMap<Integer, String>> map = new HashMap<String, HashMap<Integer, String>>();
HashMap<Integer, String> m1 = new HashMap<Integer, String>();
m1.put(1, "張三");
m1.put(2, "李四");
map.put("Java01", m1);
HashMap<Integer, String> m2 = new HashMap<Integer, String>();
m2.put(1, "小紅");
m2.put(2, "小李");
map.put("Java03", m2);
System.out.println(map);
// 獲取元素(keySet) 獲取set集合
Set<String> set = map.keySet();
// 遍歷set集合
for (String str : set) {
//獲取班級名稱
String key = str;
//獲取班級Map
HashMap<Integer, String> value = map.get(key);
System.out.println(key+"-------"+value);
//獲取班級Map中的keySet
Set<Integer> set2=value.keySet();
//遍歷學號
for(int i:set2){
//獲取學生學號
int key2=i;
//獲取學生學號所對應的姓名
String value2=value.get(key2);
System.out.println(key+"----"+key2+"-----"+value2);
}
}
System.out.println("==========================");
//用EntrySet獲取元素
//獲得映射關系set
Set<Map.Entry<String, HashMap<Integer, String>>> set2=map.entrySet();
for(Map.Entry<String, HashMap<Integer, String>> a:set2){
//獲取班級名稱
String k1=a.getKey();
//獲取班級Map
HashMap<Integer, String> v1=a.getValue();
//獲取班級Map的映射關系
Set<Map.Entry<Integer, String>> s3=v1.entrySet();
//遍歷
for(Map.Entry<Integer, String> b:s3){
//獲取學生學號
int k2=b.getKey();
//獲取學生姓名
String v2=b.getValue();
System.out.println(k1+"--"+k2+"-------"+v2);
}
}
}
}
Java學習Map接口