java集合框架之map

1:Map
    (1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
    (2)Map和Collection的区别?
        A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对
        B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍
2.Map接口功能概述(自己补齐)

package cn.itcast_01;import java.util.HashMap;import java.util.Map;import java.util.Set;/* * 作为学生来说，是根据学号来区分不同的学生的，那么假设我现在已经知道了学生的学号，我要根据学号去获取学生姓名，请问怎么做呢? * 如果采用前面讲解过的集合，我们只能把学号和学生姓名作为一个对象的成员，然后存储整个对象，将来遍历的时候，判断，获取对应的名称。 * 但是呢，如果我都能把学生姓名拿出来了，我还需要根据编号去找吗? * 针对我们目前的这种需求：仅仅知道学号，就想知道学生姓名的情况，Java就提供了一种新的集合 Map。 * 通过查看API，我们知道Map集合的一个最大的特点，就是它可以存储键值对的元素。这个时候存储我们上面的需求，就可以这样做 * 学号1姓名1 * 学号2 姓名2 * 学号3姓名3 * 学号2(不行)姓名4 * 学号4               姓名4 * Map集合的特点： * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。  *  * Map集合和Collection集合的区别? * Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对 * Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11) *  * 注意： * Map集合的数据结构值针对键有效，跟值无关 * HashMap，TreeMap等会讲。 *Collection集合的数据结构是针对元素有效 *  * Map集合的功能概述： * 1:添加功能 * V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲 * 如果键是第一次存储，就直接存储元素，返回null * 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值 * 2:删除功能 * void clear():移除所有的键值对元素 * V remove(Object key)：根据键删除键值对元素，并把值返回 * 3:判断功能 * boolean containsKey(Object key)：判断集合是否包含指定的键 * boolean containsValue(Object value):判断集合是否包含指定的值 * boolean isEmpty()：判断集合是否为空 * 4:获取功能 * Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合 * V get(Object key):根据键获取值 * Set<K> keySet():获取集合中所有键的集合 * Collection<V> values():获取集合中所有值的集合 * 5：长度功能 * int size()：返回集合中的键值对的对数 */public class MapDemo {public static void main(String[] args) {// 创建集合对象Map<String, String> map = new HashMap<String, String>();// 添加元素// V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲// System.out.println("put:" + map.put("文章", "马伊俐"));// System.out.println("put:" + map.put("文章", "姚笛"));map.put("邓超", "孙俪");map.put("黄晓明", "杨颖");map.put("周杰伦", "蔡依林");map.put("刘恺威", "杨幂");// void clear():移除所有的键值对元素// map.clear();// V remove(Object key)：根据键删除键值对元素，并把值返回// System.out.println("remove:" + map.remove("黄晓明"));// System.out.println("remove:" + map.remove("黄晓波"));// boolean containsKey(Object key)：判断集合是否包含指定的键// System.out.println("containsKey:" + map.containsKey("黄晓明"));// System.out.println("containsKey:" + map.containsKey("黄晓波"));// boolean isEmpty()：判断集合是否为空// System.out.println("isEmpty:"+map.isEmpty());//int size()：返回集合中的键值对的对数System.out.println("size:"+map.size());// 输出集合名称System.out.println("map:" + map);// 获取所有键值对对象的集合Set<Map.Entry<String, String>> set = map.entrySet();// 遍历键值对对象的集合，得到每一个键值对对象for (Map.Entry<String, String> me : set) {// 根据键值对对象获取键和值String key = me.getKey();String value = me.getValue();System.out.println(key + "---" + value);}}}}

3.Map集合的遍历
        A:键找值
            a:获取所有键的集合
            b:遍历键的集合,得到每一个键
            c:根据键到集合中去找值
        
        B:键值对对象找键和值
            a:获取所有的键值对对象的集合
            b:遍历键值对对象的集合，获取每一个键值对对象
            c:根据键值对对象去获取键和值
            
        代码体现：
            Map<String,String> hm = new HashMap<String,String>();
            
            hm.put("it002","hello");
            hm.put("it003","world");
            hm.put("it001","java");
            
            //方式1 键找值
            Set<String> set = hm.keySet();
            for(String key : set) {
                String value = hm.get(key);
                System.out.println(key+"---"+value);
            }
            
            //方式2 键值对对象找键和值
            Set<Map.Entry<String,String>> set2 = hm.entrySet();
            for(Map.Entry<String,String> me : set2) {
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key+"---"+value);

            }

4.HashMap

HashMap是基于哈希表的Map接口的非同步实现，继承自AbstractMap，AbstractMap是部分实现Map接口的抽象类。在平时的开发中，HashMap的使用还是比较多的。我们知道ArrayList主要是用数组来存储元素的，LinkedList是用链表来存储的，那么HashMap的实现原理是什么呢？先看下面这张图：

HashMap原理.jpg

在之前的版本中，HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当链表中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

package cn.itcast_02;import java.util.HashMap;import java.util.Set;/* * HashMap:是基于哈希表的Map接口实现。 * 哈希表的作用是用来保证键的唯一性的。 *  * HashMap<String,String> * 键：String * 值：String */public class HashMapDemo {public static void main(String[] args) {// 创建集合对象HashMap<String, String> hm = new HashMap<String, String>();// 创建元素并添加元素// String key1 = "it001";// String value1 = "马云";// hm.put(key1, value1);hm.put("it001", "马云");hm.put("it003", "马化腾");hm.put("it004", "乔布斯");hm.put("it005", "张朝阳");hm.put("it002", "裘伯君"); // wpshm.put("it001", "比尔盖茨");// 遍历Set<String> set = hm.keySet();for (String key : set) {String value = hm.get(key);System.out.println(key + "---" + value);}}}package cn.itcast_03;import java.util.LinkedHashMap;import java.util.Set;/* * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。 * 由哈希表保证键的唯一性 * 由链表保证键盘的有序(存储和取出的顺序一致) */public class LinkedHashMapDemo {    public static void main(String[] args) {        // 创建集合对象        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();        // 创建并添加元素        hm.put("2345", "hello");        hm.put("1234", "world");        hm.put("3456", "java");        hm.put("1234", "javaee");        hm.put("3456", "android");        // 遍历        Set<String> set = hm.keySet();        for (String key : set) {            String value = hm.get(key);            System.out.println(key + "---" + value);        }    }} 

5.TreeMap

TreeMap基于红黑树数据结构的实现，键值可以使用Comparable或Comparator接口来排序。TreeMap继承自AbstractMap，同时实现了接口NavigableMap，而接口NavigableMap则继承自SortedMap。SortedMap是Map的子接口，使用它可以确保图中的条目是排好序的。

在实际使用中，如果更新图时不需要保持图中元素的顺序，就使用HashMap，如果需要保持图中元素的插入顺序或者访问顺序，就使用LinkedHashMap，如果需要使图按照键值排序，就使用TreeMap。

package cn.itcast_04;import java.util.Set;import java.util.TreeMap;/* * TreeMap:是基于红黑树的Map接口的实现。 *  * HashMap<String,String> * 键：String * 值：String */public class TreeMapDemo {public static void main(String[] args) {// 创建集合对象TreeMap<String, String> tm = new TreeMap<String, String>();// 创建元素并添加元素tm.put("hello", "你好");tm.put("world", "世界");tm.put("java", "爪哇");tm.put("world", "世界2");tm.put("javaee", "爪哇EE");// 遍历集合Set<String> set = tm.keySet();for (String key : set) {String value = tm.get(key);System.out.println(key + "---" + value);}}}

6.

Hashtable
HashTable和前面介绍的HashMap很类似，它也是一个散列表，存储的内容是键值对映射，不同之处在于，HashTable是继承自Dictionary的，HashTable中的函数都是同步的，这意味着它也是线程安全的，另外，HashTable中key和value都不可以为null。

package cn.itcast_07;import java.util.Hashtable;/* * 1:Hashtable和HashMap的区别? * Hashtable:线程安全，效率低。不允许null键和null值 * HashMap:线程不安全，效率高。允许null键和null值 *  * 2:List,Set,Map等接口是否都继承子Map接口? * List，Set不是继承自Map接口，它们继承自Collection接口 * Map接口本身就是一个顶层接口 */public class HashtableDemo {public static void main(String[] args) {// HashMap<String, String> hm = new HashMap<String, String>();Hashtable<String, String> hm = new Hashtable<String, String>();hm.put("it001", "hello");// hm.put(null, "world"); //NullPointerException// hm.put("java", null); // NullPointerExceptionSystem.out.println(hm);}}

7.

Collections(理解)    
    (1)是针对集合进行操作的工具类
    (2)面试题：Collection和Collections的区别
        A:Collection 是单列集合的顶层接口，有两个子接口List和Set
        B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
    (3)常见的几个小方法：
        A:public static <T> void sort(List<T> list)
        B:public static <T> int binarySearch(List<?> list,T key)
        C:public static <T> T max(Collection<?> coll)
        D:public static void reverse(List<?> list)
        E:public static void shuffle(List<?> list)

package cn.itcast_01;import java.util.Collections;import java.util.List;import java.util.ArrayList;/* * Collections:是针对集合进行操作的工具类，都是静态方法。 *  * 面试题： * Collection和Collections的区别? * Collection:是单列集合的顶层接口，有子接口List和Set。 * Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法 *  * 要知道的方法 * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。 * public static <T> int binarySearch(List<?> list,T key):二分查找 * public static <T> T max(Collection<?> coll):最大值 * public static void reverse(List<?> list):反转 * public static void shuffle(List<?> list):随机置换 */public class CollectionsDemo {public static void main(String[] args) {// 创建集合对象List<Integer> list = new ArrayList<Integer>();// 添加元素list.add(30);list.add(20);list.add(50);list.add(10);list.add(40);System.out.println("list:" + list);// public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。// Collections.sort(list);// System.out.println("list:" + list);// [10, 20, 30, 40, 50]// public static <T> int binarySearch(List<?> list,T key):二分查找// System.out// .println("binarySearch:" + Collections.binarySearch(list, 30));// System.out.println("binarySearch:"// + Collections.binarySearch(list, 300));// public static <T> T max(Collection<?> coll):最大值// System.out.println("max:"+Collections.max(list));// public static void reverse(List<?> list):反转// Collections.reverse(list);// System.out.println("list:" + list);//public static void shuffle(List<?> list):随机置换Collections.shuffle(list);System.out.println("list:" + list);}}

 8.总结

     Collection集合总结(掌握)
    Collection
        |--List    有序,可重复
            |--ArrayList
                底层数据结构是数组，查询快，增删慢。
                线程不安全，效率高
            |--Vector
                底层数据结构是数组，查询快，增删慢。
                线程安全，效率低
            |--LinkedList
                底层数据结构是链表，查询慢，增删快。
                线程不安全，效率高
        |--Set    无序,唯一
            |--HashSet
                底层数据结构是哈希表。
                如何保证元素唯一性的呢?
                    依赖两个方法：hashCode()和equals()
                    开发中自动生成这两个方法即可
                |--LinkedHashSet
                    底层数据结构是链表和哈希表
                    由链表保证元素有序
                    由哈希表保证元素唯一
            |--TreeSet
                底层数据结构是红黑树。
                如何保证元素排序的呢?
                    自然排序
                    比较器排序
                如何保证元素唯一性的呢?
                    根据比较的返回值是否是0来决定

      Map(双列集合)存储的是键值对形式的元素，键唯一，值可以重复

   Hashmap

        底层数据结构是哈希表。
                    依赖两个方法：hashCode()和equals()
                    开发中自动生成这两个方法即可
                |--Linkedmap
                    底层数据结构是链表和哈希表
                    由链表保证元素有序
                    由哈希表保证元素唯一

      hashtable  线程安全的

  treemap

   底层数据结构是红黑树。
                如何保证元素排序的呢?
                    自然排序
                    比较器排序
                如何保证元素唯一性的呢?
                    根据比较的返回值是否是0来决定

                  
4:针对Collection集合我们到底使用谁呢?(掌握)
    唯一吗?
        是：Set
            排序吗?
                是：TreeSet
                否：HashSet
        如果你知道是Set，但是不知道是哪个Set，就用HashSet。
            
        否：List
            要安全吗?
                是：Vector
                否：ArrayList或者LinkedList
                    查询多：ArrayList
                    增删多：LinkedList
        如果你知道是List，但是不知道是哪个List，就用ArrayList。
    
    如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
    
    如果你知道用集合，就用ArrayList。
    
5:在集合中常见的数据结构(掌握)
    ArrayXxx:底层数据结构是数组，查询快，增删慢
    LinkedXxx:底层数据结构是链表，查询慢，增删快
    HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
    TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序