Java學習Map接口
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接口