方法 | 描述 |
---|---|
V put(K key, V value) | 将指定的值与该映射中的指定键相关联(可选操做)。 |
V remove(Object key) | 若是存在(从可选的操做),从该地图中删除一个键的映射。 |
V get(Object key) | 返回到指定键所映射的值,或 null若是此映射包含该键的映射。 |
boolean containsKey(Object key) | 若是此映射包含指定键的映射,则返回 true 。 |
Set
|
返回此地图中包含的键的Set视图。 |
Set<Map.Entry<K,V>> entrySet() | 返回此地图中包含的映射的Set视图。 |
内部接口:Entry<K,V>java
做用:当Map集合建立,就会建立一个Entry对象,用来存储键值对。面试
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * 测试Map集合的经常使用方法 * add、remove、get、containKey、keySet、entrySet */ public class TestMap { public static void main(String[] args) { HashMap<String, String> map = new HashMap<>(); // put的返回值是被替代的V,若是原来没有就是null System.out.println(map.put("1001", "张三")); System.out.println(map.put("1001", "张三丰")); map.put("1002", "李四"); map.put("1003", "王五"); System.out.println(map); // remove返回被删除的V,Key不存在则返回null System.out.println(map.remove("1005")); System.out.println(map.remove("1003")); System.out.println(map); // get返回key对应的value, 无则null System.out.println(map.get("1002")); System.out.println(map.get("1003")); // containsKey 包含key返回true System.out.println(map.containsKey("1002")); System.out.println(map.containsKey("1003")); System.out.println("遍历方式1:将全部key取出来存到set集合"); Set<String> keys = map.keySet(); for (String key : keys) { System.out.println("K:"+key+" V:"+map.get(key)); } System.out.println("遍历方式2:将全部Entry<K,V>对象取出来存到set集合"); for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println(entry.getKey() + "=" + entry.getValue()); } } }
运行结果数组
null 张三 {1003=王五, 1002=李四, 1001=张三丰} null 王五 {1002=李四, 1001=张三丰} 李四 null true false 遍历方式1:将全部key取出来存到set集合 K:1002 V:李四 K:1001 V:张三丰 遍历方式2:将全部Entry<K,V>对象取出来存到set集合 1002=李四 1001=张三丰
基于哈希表的实现的Map
接口。 此实现提供了全部可选的Map操做,并容许null
值和null
键。安全
底层是哈希表,查询速度超级快!多线程
JDK8以前:数组+链表ide
JDK8以后:数组+链表 / 数组+红黑树学习
HashMap面试须要更深的理解,深刻底层!测试
目前停留于了解原理,掌握运用。this
首先建立一个学生类线程
package map; public class Student{ private int id; private String name; private int age; public Student() { } public Student(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } 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 "Student{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}'; } }
测试类
package map; import java.util.HashMap; /** * 若以自定义类做键存放,必须说明键重复的规则 * 实体类重写hashCode方法和equals方法 * 好比学生类中,同名不必定是同一个对象,同窗号说明是同一个学生 */ public class TestHashMap { public static void main(String[] args) { Student student1 = new Student(1001, "张三", 18); Student student2 = new Student(1002, "李四", 17); Student student3 = new Student(1001, "张三", 19); Student student4 = new Student(1004, "李四", 20); HashMap<Student, String> map = new HashMap<>(); map.put(student1, "第一名"); map.put(student2, "第二名"); map.put(student3, "第三名"); map.put(student4, "第四名"); System.out.println(map); } }
运行结果
{Student{id=1004, name='李四', age=20}=第四名, Student{id=1002, name='李四', age=17}=第二名, Student{id=1001, name='张三', age=18}=第一名, Student{id=1001, name='张三', age=19}=第三名}
此时观察student1 和 student3 的学号相同,对象重复,为何还会添加到map中呢?
有提示要重写Student类的hashCode方法和equals方法。
修改后的Student.java
package map; import java.util.Objects; public class Student{ private int id; private String name; private int age; public Student() { } public Student(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } // ...get/set省略 @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return id == student.id; } @Override public int hashCode() { return Objects.hash(id); } }
再次运行测试类的代码获得的结果
{Student{id=1001, name='张三', age=18}=第三名, Student{id=1002, name='李四', age=17}=第二名, Student{id=1004, name='李四', age=20}=第四名}
分析:第一次添加1001学生时,value是第一名,再次遇到1001学生,覆盖了原来的value
更加详细的学习会写到另外一篇
哈希表和链表实现的Map
接口,具备可预测的迭代次序。有序集合!
public class LinkedHashMap<K,V>extends HashMap<K,V>implements Map<K,V>{}
import java.util.*; public class TestLinkedHashMap { public static void main(String[] args) { HashMap<String, String> map = new HashMap<>(); map.put("1001", "张三"); map.put("1002", "李四"); map.put("1003", "王五"); map.put("1004", "赵六"); System.out.println("map的数据无序,取出的结果与存入顺序不一致:"); System.out.println(map); System.out.println(); LinkedHashMap<String, String> link = new LinkedHashMap<>(); link.put("1001", "张三"); link.put("1002", "李四"); link.put("1003", "王五"); link.put("1004", "赵六"); System.out.println("在map外层加一层链表记录元素存入的顺序:"); System.out.println(link); } }
运行结果
map的数据无序,取出的结果与存入顺序不一致: {1004=赵六, 1003=王五, 1002=李四, 1001=张三} 在map外层加一层链表记录元素存入的顺序: {1001=张三, 1002=李四, 1003=王五, 1004=赵六}
Hashtable 和 Vector 同样都是上古级别的集合,在jdk1.2版本以后被更先进的HashMap及ArrayList集合取代。
值得注意的是,Hashtable的子类Properties目前依旧活跃着,它是惟一和IO流结合的集合。
底层都是哈希表,元老级更注重线程安全。
Hashtable
HashMap
import java.util.HashMap; import java.util.Hashtable; public class TestHashtable { public static void main(String[] args) { HashMap<String, String> map = new HashMap<>(); map.put(null, null); map.put("A", null); map.put(null, "B"); System.out.println(map); Hashtable<String, String> table = new Hashtable<>(); //table.put(null, null);//NullPointerException //table.put("A", null);//NullPointerException //table.put(null, "B");//NullPointerException System.out.println(table); } }
运行结果
{null=B, A=null} {}
HashMap中以null做为键时,再次添加null的键会覆盖以前的value值。
Hashtable只要涉及到null,就会报空指针异常。
判断字符串中某个字符出现的次数
import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.Scanner; /** * 判断字符串中某个字符出现的次数 */ public class MapPractice { public static void main(String[] args) { Map<Character, Integer> map = new LinkedHashMap<>(); // Scanner sc = new Scanner(System.in); // String str = sc.nextLine(); String str = "aaabbcdaabb"; char[] chars = str.toCharArray(); for (char ch : chars) { if (map.get(ch) == null) { map.put(ch, 1); } else { int count = map.get(ch); map.put(ch, ++count); } } // 使用linkedHashMap保证从前日后统计的顺序 System.out.println(map); } }
斗地主发牌
import java.util.*; /** * 扑克发牌并按大小排序 */ public class PracticePoker { public static void main(String[] args) { // 存放索引的map,一个索引对应一张牌,按照必定规则定制 Map<Integer, String> map = new HashMap<>(); // 存放牌色♠♥♦♣、数字的列表 List<String> colors = new ArrayList<>(); List<String> numbers = new ArrayList<>(); Collections.addAll(colors, "♠", "♥", "♣", "♦"); Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"); // 创建索引与牌的映射 0-"大王" 1-"小王" 2-"2♠" 3-"2♥" ... int idx = 0; map.put(idx++, "大王"); map.put(idx++, "小王"); for (String number : numbers) { for (String color : colors) { map.put(idx++, number + color); //System.out.print(number + color + " "); } } // 发牌发的是索引,便于比大小 , 由于set是无序的,不能洗牌 Set<Integer> idxSet = map.keySet(); ArrayList<Integer> idxList = new ArrayList<>(idxSet); // System.out.println("洗牌前" + idxList); Collections.shuffle(idxList); // System.out.println("洗牌后" + idxList); // 玩家的牌用列表接收,便于排序 ArrayList<Integer> playA = new ArrayList<>(); ArrayList<Integer> playB = new ArrayList<>(); ArrayList<Integer> playC = new ArrayList<>(); ArrayList<Integer> special = new ArrayList<>(); // 发牌 special.add(idxList.get(0)); special.add(idxList.get(1)); special.add(idxList.get(2)); for (int i = 3; i < idxList.size(); i++) { if (i % 3 == 0) { playA.add(idxList.get(i)); } else if (i % 3 == 1) { playB.add(idxList.get(i)); } else if (i % 3 == 2) { playC.add(idxList.get(i)); } } // 排序 Collections.sort(playA); Collections.sort(playB); Collections.sort(playC); Collections.sort(special); // 看牌 lookPoker("刘德华", playA, map); lookPoker("周润发", playB, map); lookPoker("周星驰", playC, map); lookPoker("底牌", special, map); } public static void lookPoker(String name, List<Integer> idxList, Map<Integer, String> poker) { System.out.print(name + "的牌为:"); for (Integer idx : idxList) { System.out.print(poker.get(idx) + " "); } System.out.println(); } }
结果
刘德华的牌为:2♥ 2♦ A♥ A♣ A♦ K♠ K♦ Q♥ J♠ 10♠ 8♥ 8♦ 7♠ 6♣ 5♣ 4♣ 3♥ 周润发的牌为:2♠ 2♣ K♣ Q♠ J♣ J♦ 9♥ 9♦ 8♠ 7♣ 7♦ 6♥ 5♠ 5♥ 4♥ 4♦ 3♠ 周星驰的牌为:大王 小王 A♠ K♥ Q♣ Q♦ J♥ 10♣ 10♦ 9♠ 8♣ 7♥ 6♠ 6♦ 5♦ 4♠ 3♦ 底牌的牌为:10♥ 9♣ 3♣