import java.util.HashMap; import java.util.Map; /* * java.until.Map<k,v>集合 * Map集合的特点 * 1、Map集合是一个双列集合，一个元素包含俩个值(一个key，一个value) * 2、Map集合中的元素，key和value类型可以相同也可以不同 * 3、Map集合中的元素key是不可以重复的，value是可以重复的 * 4、Map集合中的元素key和value是一对 * java.util.HashMap<k,v>集合 implements Map<k,y>接口 * HashMap集合特点： * 1、HashMap集合底层是哈希表：查询速度快 * JDK1.8之前：数组+单向链表 * JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度 * 2、hashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一样 * java.util.LinkedHashMap<K,V>集合 extends HashMap<k,v>集合 * linkedHashMap的特点: * 1、LinkedHashMap结合底层是哈希表+链表(保证迭代的顺序) * 2、LinkedHashMap集合是一个有序的结合存取元素是有序的 * */ public class Demo01Map { public static void main(String[] args) { show4(); } /* * boolean containKey(Object key)判断集合中是否包含指定的键 * 包含返回true，。不包含false */ private static void show4(){ Map<String,Integer> map = new HashMap<>(); map.put("赵丽颖", 168); map.put("杨颖", 165); map.put("杨", 160); boolean b1 = map.containsKey("赵丽颖"); System.out.println("b1:"+b1); } /* public V get (Object key)根据指定的键，在map中获取对应的值 * 返回值： * key存在，返回对应的value * key不存在，value返回为null * */ private static void show3(){ Map<String,Integer> map = new HashMap<>(); map.put("赵丽颖", 168); map.put("杨颖", 165); map.put("杨", 160); Integer v1=map.get("杨"); System.out.println(v1); System.out.println(map); } /*public V remove(Object key):把指定的键 所对应的键值对元素 在Map集合中删除，返回删除元素的值 * 返回值：V, * key存在，v返回被删除的值 * key不存在，返回值为null * */ private static void show2(){ Map<String,Integer> map = new HashMap<>(); map.put("赵丽颖", 168); map.put("杨颖", 165); map.put("杨", 160); map.put("林志玲", 178); System.out.println(map); Integer v1 = map.remove("赵丽颖");//可以用int自动拆箱接收但是会报空指针异常 System.out.println("v1:"+v1); System.out.println(map); } //把指定的键值对添加到map集合当中 //public v put(K key,V value): /* * 返回值为:v * 存储键值对时候key不重复，返回值为v是null * 存储键值对的时候key重复，会使用新的value替换重复当中的value返回被替换的value * * */ public static void show1(){ //创建Map集合 Map<String,String> map = new HashMap<>(); String v1 = map.put("李晨", "范冰冰"); System.out.println("v1:"+v1); System.out.println(map); map.put("杨过","小龙女"); } }
Map.Entry<K,V>:在Map接口中有一个内部接口Entry
作用：当Map集合已创建，那么就会在Map集合中创建一个Entry对象,用来记录键与值(键值对对象，键与值的映射关系)->结婚证
Set<Map.Entry<K,V>> entrySet
把map集合内部的多个Entry对象取出来存储到一个Set集合当中
遍历Set集合，获取Set集合中的每一个entry对象
Map.Entry<黄晓明，杨颖>
使用Entry中的方法getKey()获取key
使用getValue()获取value
Map集合遍历键找值方式：
通过元素中的键获取对应的值
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /* * Map集合的第一种遍历方式：通过键找值的方式： * Map集合中的方法 * Set<K> keySet() * 返回刺激和中包含的Set视图 * 实现步骤： * 1、使用Map中的方法keySet()，把Map集合所有的key取出来，存储到一个Set集合中 * 2、遍历set集合，获取Map集合当中的每一个key * 3、通过Map集合中的方法get(key),通过key找到value */ public class Demo02KeySet { public static void main(String[] args) { // TODO Auto-generated method stub Map<String,Integer> map = new HashMap<>(); map.put("赵丽颖", 168); map.put("杨颖", 165); map.put("杨", 160); //1、使用map集合当中的方法keySet，把map集合所有的key取出来，存储到一个色统计和当中 Set<String> set = map.keySet(); //2、使用set集合，获取map集合中每一个key //使用迭代器遍历Set集合 Iterator<String> it =set.iterator(); while(it.hasNext()){ String key = it.next(); //3、通过Map集合中的方法get(key)，通过key找到value Integer value= map.get(key); System.out.println("key="+key+"value="+value); } System.out.println("===-------------------------------"); //也可以使用增强for循环 for(String key:set){ //3、通过Map集合中的方法get(key)，通过key找到value Integer value= map.get(key); System.out.println("key="+key+"value="+value); } } }
遍历键值对方式二：
1 import java.util.HashMap; 2 import java.util.Iterator; 3 import java.util.Map; 4 import java.util.Set; 5 6 /* 7 * Map集合的第二种遍历方式： 8 * 使用Entry对象遍历 9 * Map集合中的方法： 10 * Set<Map.Entry<K,V>> entrySet() 返回映射中包含的映射关系的Set视图 11 * 12 * 实现步骤： 13 * 1、使用Map集合中的方法entrySet()，把Map集合中的多个Entry对象取出来存储到一个Set集合当中 14 * 2、遍历Set集合获取每一个Entry对象 15 * 3、使用Entry对象中的方法getKey()和getValue()获取键与值 16 */ 17 public class Demo03EntrySet { 18 19 public static void main(String[] args) { 20 // TODO Auto-generated method stub 21 //创建Map集合对象 22 Map<String,Integer> map = new HashMap<>(); 23 map.put("赵丽颖", 168); 24 map.put("杨颖", 165); 25 map.put("杨", 160); 26 27 28 //使用Map集合中的方法entrySet()，把Map集合中多个Entry对象取出来，存储到一个set集合中 29 30 Set<Map.Entry<String,Integer>> set = map.entrySet(); 31 //遍历Set集合获取每一个Entry对象 32 //使用迭代器遍历Set集合 33 Iterator<Map.Entry<String,Integer>> it = set.iterator(); 34 while(it.hasNext()){ 35 Map.Entry<String,Integer> entry = it.next();//取出每一个entry对象 36 //3、使用Entry对象中的方法getKey()和getValue()获取键与值 37 String key = entry.getKey(); 38 Integer value =entry.getValue(); 39 System.out.println("key:"+key+"value:"+value); 40 41 } 42 System.out.println("----------------------"); 43 //增强for循环 44 // *增强for循环：底层也是使用的迭代器， 45 // *使用for循环的格式简化了迭代器 46 // * 47 // *Collection<E>extends Iterable<E>：所有的单列集合都可以使用增强for循环 48 // *public interface Iterable<T>实现这个接口允许对象成为 "foreach" 语句的目标。 49 // 50 // 增强for循环：用来遍历集合和数组 51 // 格式： 52 // for(集合/数组的数据类型 变量名： 集合名/数组名){ 53 // sout(变量名); 54 // } 55 for(Map.Entry<String,Integer> entry:set){ 56 //3、使用Entry对象中的方法getKey()和getValue()获取键与值 57 String key = entry.getKey(); 58 Integer value =entry.getValue(); 59 System.out.println("key:"+key+"value:"+value); 60 61 } 62 63 } 64 65 }
HashMap存储自定义类型键值
Person类：
1 package com.learn.map.person; 2 3 public class Person { 4 private String name; 5 private int age; 6 7 public Person(){ 8 9 } 10 11 public Person(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 33 @Override 34 public String toString() { 35 return "Person [name=" + name + ", age=" + age + "]"; 36 } 37 38 @Override 39 public int hashCode() { 40 final int prime = 31; 41 int result = 1; 42 result = prime * result + age; 43 result = prime * result + ((name == null) ? 0 : name.hashCode()); 44 return result; 45 } 46 47 @Override 48 public boolean equals(Object obj) { 49 if (this == obj) 50 return true; 51 if (obj == null) 52 return false; 53 if (getClass() != obj.getClass()) 54 return false; 55 Person other = (Person) obj; 56 if (age != other.age) 57 return false; 58 if (name == null) { 59 if (other.name != null) 60 return false; 61 } else if (!name.equals(other.name)) 62 return false; 63 return true; 64 } 65 66 }
主方法实现：
1 import java.util.HashMap; 2 import java.util.Map; 3 import java.util.Set; 4 5 /* 6 * HashMap存储自定义类型键值 7 * Map集合保证key是唯一的： 8 * 作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一 9 */ 10 public class Demo01HashMapSavePerson { 11 public static void main(String[] args){ 12 show02(); 13 14 } 15 16 /* 17 * HashMap存储自定义类型键值 18 * key：Person类型 19 * Person类 必须重写hashCode方法和equals方法以保证key唯一 20 * value：String类型 21 * 可以重复 22 * 23 * 24 */ 25 public static void show02(){ 26 //创建HashMap集合 27 HashMap<Person,String> map = new HashMap<>(); 28 map.put(new Person("女王",18), "英国"); 29 map.put(new Person("秦始皇",40), "秦国"); 30 map.put(new Person("李世明",18), "唐朝"); 31 map.put(new Person("孙悟空",18), "美猴国"); 32 map.put(new Person("玉皇大帝",18), "仙人果"); 33 map.put(new Person("女王",18), "毛里求斯"); 34 35 36 //使用entrySet和增强for遍历map集合 37 Set<Map.Entry<Person, String>> set = map.entrySet(); 38 for(Map.Entry<Person, String> entry:set){ 39 Person key = entry.getKey(); 40 String value = entry.getValue(); 41 System.out.println(key+"-->"+value); 42 } 43 44 45 46 47 48 49 50 51 } 52 53 54 55 56 57 58 59 /* 60 * HashMap存储自定义存储类型赋值 61 * key：String类型 62 * String类重写hahshCiode方法和equals方法，可以保证key唯一 63 * value：Person类型 64 * value可以重复（同名同年龄视为同一个人） 65 * 66 */ 67 public static void show01(){ 68 //创建hashMap集合 69 HashMap<String,Person> map = new HashMap<>(); 70 71 //往集合中添加元素 72 map.put("北京", new Person("张三",18)); 73 map.put("上海", new Person("李三",15)); 74 map.put("深圳", new Person("刘三",13)); 75 map.put("北京", new Person("夏三",19)); 76 map.put("天津", new Person("吴三",21)); 77 78 //使用keySet加强for遍历map集合 79 Set<String> set = map.keySet();//把key取出来放到set集合当中 80 81 for(String key:set){ 82 //在通过map.get(key)方法找到value 83 Person value=map.get(key); 84 System.out.println(key+"-->"+value); 85 } 86 87 88 89 90 91 } 92 93 }
LinkedHashMap集合：
1 import java.util.HashMap; 2 import java.util.LinkedHashMap; 3 4 /* 5 * java.util.linkedHashMap<K,V> extends HashMap<K,V> 6 * Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。 7 * 底层原理 8 * 哈希表+链表(记录元素的顺序) 9 */ 10 public class Demmo01LinkedHashMap { 11 12 public static void main(String[] args) { 13 // TODO Auto-generated method stub 14 HashMap<String,String> map = new HashMap<>(); 15 16 map.put("a", "b"); 17 map.put("c", "c"); 18 map.put("d", "d"); 19 map.put("a", "d"); 20 System.out.println(map);//key不允许重复无序集合 21 22 23 LinkedHashMap<String,String> linked = new LinkedHashMap<>(); 24 25 linked.put("a", "b"); 26 linked.put("c", "c"); 27 linked.put("d", "d"); 28 linked.put("a", "d"); 29 System.out.println(linked);//key不可以重复，有序集合 30 31 } 32 33 }
Hashtable<K,V>
1 import java.util.HashMap; 2 import java.util.Hashtable; 3 4 /* 5 * java.util.Hashtable<K,V>集合 implements Map<K,V>接口 6 * 7 * Hashtable：底层也是一个哈希表，是一个单线程安全的集合，是单线程集合，速度慢 8 * HashMap集合：底层是一个哈希表是一个线程不安全的集合，是多线程的集合，速度快 9 * 10 * HashMap集合（之前学的所有的集合）：可以存储null，和null键 11 * Hashtabvle集合，不能存储null值，和null键 12 * 13 * Hashtable和vector集合一样在jdk1.2版本之后被更先进的集合取代了（HashMap，ArrayList） 14 * Hashtable的子类叫Properties依然活跃在历史的舞台上 15 * Properties集合是一个唯一与IO刘相结合的集合 16 */ 17 public class Demo02Hashtable { 18 19 public static void main(String[] args) { 20 // TODO Auto-generated method stub 21 HashMap<String,String> map = new HashMap<>(); 22 map.put(null, "a"); 23 map.put(null, null); 24 map.put("b", null); 25 26 System.out.println(map); 27 28 Hashtable<String,String> table = new Hashtable<>(); 29 // table.put(null, "a");//报错空指针异常 30 31 32 33 }
jdk9的新特性
* list接口，Set接口，Map接口;里面增加了一个静态方法of可以给集合一次性添加多个元素
* static <E> list <E> of(E...elements)
* 使用前提：
* 当集合中存储元素的个数确定不在改变时，可以使用
* 注意：
* 1、of方法只适用于list接口，Set接口，Set接口，不适用于接口的实现类
* 2、of方法的返回值不可以改变的集合，集合不能再使用add和put方法添加元素了，会抛出异常
* 3、Set接口和Map接口在调用of方法时，不能有重复元素否者也会抛出异常