Map集合

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方法时，不能有重复元素否者也会抛出异常