Map接口

最新推荐文章于 2022-03-09 16:23:16 发布

春水煎茶

最新推荐文章于 2022-03-09 16:23:16 发布

阅读量345

点赞数

分类专栏： Java高级编程文章标签： java

本文链接：https://blog.csdn.net/weixin_44065652/article/details/120374695

版权

Java高级编程专栏收录该内容

52 篇文章 3 订阅

订阅专栏

Map接口继承树：

Map实现类的结构：

Map：双列数据，存储key-value对的数据，类似于高中的函数：y=f(x)

HashMap：作为Map的主要实现类，线程不安全的，效率高，存储null的key和value；

LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。

原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素对于频繁的遍历操作，此类执行效率高于HashMap。

TreeMap：保证按照添加key-value对进行排序，实现排序遍历，此时考虑key的自然排序或定

制排序。底层使用红黑树

Hashtable：作为古老的实现类，线程安全的，效率低，不能存储null的key和value；

Properties：常用来处理配置文件。key和value都是String类型。

HashMap的底层：数组+链表（jdk7及以前）

数组+链表+红黑树（jdk8）

Map结构的理解：

Map中的key：无序的、不可重复的，使用Set存储所有的key。——>key所在的类要重写equals()和hashCode()(以HashMap为例)。

Map中的value：无序的、可重复的，使用Collection存储所有的value——>value所在的类要重写equals()

一个键值对：key-value构成了一个Entry对象。

Map中的entry：无序的、不可重复的，使用Set存储所有的entry。

Map实现类之一：HashMap

1）HashMap是Map接口使用频率最高的实现类。

2）允许使用null键和null值，与HashSet一样，不能保证映射的顺序。

3）所有的key构成的集合是Set：无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。

4）所有的value构成的集合是Collection：无序的、可以重复的。所以，value所在的类要重写：equals()。

5）一个key-value构成一个entry。

6）所有的entry构成的集合是Set：无序的、不可重复的。

7）HashMap判断为两个key相等的标准是：两个key通过equals()方法返回true，hashCode值也相等。

8）HashMap判断两个value相等的标准是：两个value通过equals()方法返回true。

 @Test
    public void test1(){
        Map map=new HashMap();

        //map=new HashMap();
        map.put(null,123);
        map.put(null,null);
        System.out.println(map);//{null=null}
    }

    @Test
    public void test2(){
        Map map=new HashMap();

        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");

        System.out.println(map);//{345=BB,123=AA,12=CC}
    }

HashMap的底层实现原理：（以jdk7为例说明）

HashMap map=new HashMap()：在实例化以后，底层创建了长度为16的一维数组Entry[] table

...(可能已经执行过多次put)...

map.put(key1,value1)：

首先，调用key1所在的类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。——情况一

如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：

如果key1的哈希值和已经存在的数据的哈希值都不相同，此时key1-value1添加成功——情况二

如果key1的哈希值和已经存在的某一个数据key2-value2的哈希值相同，继续比较：调用key1所在类的equals()方法，比较

如果equals()返回false：此时key1-value1添加成功——情况三

如果equals()返回true：使用value1替换相同的key的value2值

补充：关于情况二和情况三：此时key1-value1和原来的数据以链表的方式存储

在不断添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空时），扩容。默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来

HashMap的扩容（JDKK1.8之前）：

当HashMap中的元素越来越多的时候，hash冲突的纪律也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

HashMap什么时候进行扩容：

当HashMap中的元素个数超过数组大小（数组总大小length，不是数组中个数size）*loadFactor时，就会进行数组扩容，loadFactor的默认值（DEFAULT_LOAD_FACTOR）为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小（DEFAULT_INITIAL_CAPACITY）为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threahold值，也叫做临界值）的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

HashMap的存储结构（JDK1.8）：

1）HashMap的内部存储结构其实是数组+链表+树的结合。当实例化一个HashMap时，会初始化initialCapacity和loaadFactor，在put第一对映射关系时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表中称为容量（Capacity），在这个数组中可以存放元素的位置我们称之为“桶”（bucket），每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

2）每个bucket中存储一个元素，及一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。而新添加的元素作为链表的last，或树的叶子节点。

负载因子值得大小，对HashMap有什么影响：

1）负载因子得大小决定了HashMap的数据密度。

2）负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长，造成查询或插入时的比较次数增多，性能会下降。

3）负载因子越小，越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。

4）按照其他语言的参考和研究经验，会考虑负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

jdk8相较于jdk7在底层实现方面的不同：

1）new HashMap()：底层没有创建一个长度为16的数组

2）jdk8底层的数组是：Node[],而非Entry[]

3）首次调用put()方法时，底层创建长度为16的数组

4）jdk7底层结构只有：数组+链表。 jdk8中底层结构：数组+链表+红黑树

当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储

HashMap源码中的重要常量：

DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16

MAXIMUM_CAPACITY：HashMap的最大支持容量，2^30

DEFAULT_LOAD_FACTOR：HashMap的默认加载因子

TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树

UNTREEIFY_THRESHOLD：Bucket中红黑树存储的Node小于该默认值，转化为链表

MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍）。

table：存储元素的数组，总是2的n次幂

entrySet：存储具体元素的集

size：HashMap中存储的键值对的数量

modCount：HashMap扩容和结构改变的次数

threshold：扩容的临界值，=容量*填充因子

loadFactor：填充因子

LinkedHashMap的底层实现原理：

HashMap中的内部类：Node

static class Node<K,V> implements Map.Entry<K,V>{
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

LinkedHashMap中的内部类：Entry

static class Entry<K,V> extends HashMap.Node<K,V>{
    Entry<K,V> before,after;//能够记录添加的元素的先后顺序
    Entry(int hash,K key,V value,Node<K,V> next){
        super(hash,key,value,next);
    }
}

Map接口常用方法：

添加、删除、修改操作：

ObJect put(Object key,Object value)：将指定key-value添加到（或修改）当前map对象中。

void putAll(Map m)：将m中的所有key-value对村梵高当前map中。

Object remove(Object key)：移除指定key的key-value对，并返回value。

void clear()：清空当前map中的所有数据。

元素查询操作：

Object get(Object key)：获取指定key对应的value。

boolean containsKey(Object key)：是否包含指定的key。

boolean containsValue(Object value)：是否包含指定的value。

int size()：返回map中key-value对的个数。

boolean isEmpty()：判断当前map是否为空。

boolean equals(Object obj)：判断当前map和参数对象obj是否相等。

元视图操作的方法：

Set keySet()：返回所有key构成的Set集合

Collection values()：返回所有value构成的Collection集合。

Set entrySet()：返回所有key-value对构成的Set集合。

 /*
    添加、删除、修改操作：
    ObJect put(Object key,Object value)：将指定key-value添加到（或修改）当前map对象中。
    void putAll(Map m)：将m中的所有key-value对村梵高当前map中。
    Object remove(Object key)：移除指定key的key-value对，并返回value。
    void clear()：清空当前map中的所有数据。
     */
    @Test
    public void test3(){
        Map map=new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);

        System.out.println(map);//{AA=87, BB=56, 45=123}

        Map map1=new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);

        System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}

        //remove(Object key)
        Object value=map.remove("CC");
        System.out.println(value);//123
        System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}

        Object value1=map.remove("CCC");
        System.out.println(value);//null：因为不存在所以返回null
        System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}

        //clear()
        map.clear();//与map=null操作不同
        System.out.println(map.size());//0
        System.out.println(map);//{}
    }

    /*
    元素查询操作：
    Object get(Object key)：获取指定key对应的value。
    boolean containsKey(Object key)：是否包含指定的key。
    boolean containsValue(Object value)：是否包含指定的value。
    int size()：返回map中key-value对的个数。
    boolean isEmpty()：判断当前map是否为空。
    boolean equals(Object obj)：判断当前map和参数对象obj是否相等。
     */
    @Test
    public void test4(){
        Map map=new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);

        //Object get(Object key)
        System.out.println(map.get(45));//123
        //containsKey(Object key)
        boolean isExist=map.containsKey("BB");
        System.out.println(isExist);//true

        isExist=map.containsValue(123);
        System.out.println(isExist);//true

        map.clear();
        System.out.println(map.isEmpty());//true
    }

     /*
    元视图操作的方法：
    Set keySet()：返回所有key构成的Set集合.
    Collection values()：返回所有value构成的Collection集合。
    Set entrySet()：返回所有key-value对构成的Set集合。
     */
    @Test
    public void test5(){
        Map map=new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set=map.keySet();
        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());//AA BB 45
        }

        //遍历所有的value集：values()
        Collection values=map.values();
        for(Object obj:values){
            System.out.println(obj);//123 56 1234
        }

        //遍历所有的key-value
        //entrySet():
        Set entrySet=map.entrySet();
        Iterator iterator1=entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj=iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry=(Map.Entry) obj;
            System.out.println(entry.getKey()+"--->"+entry.getValue());
            //AA--->123 BB--->56 45--->1234
        }
        //方式二：
        Set keySet=map.keySet();
        Iterator iterator2=set.iterator();
        while(iterator.hasNext()){
            Object key=iterator2.next();
            Object value=map.get(key);
            System.out.println(key+"===="+value);
            //AA====123 BB====56 45====1234
        }

    }

总结：常用方法：
添加：put(Object key,Object value)

删除：remove(Object key)

修改：put(Object key,Object value)

查询：get(Object key)

长度：size()

遍历：keySet() / values() / entrySet()

TreeMap两种添加方式的使用：

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象，因为要按照key进行排序：自然排序、定制排序

//自然排序
    @Test
    public void test1(){
        TreeMap map=new TreeMap();
        User u1=new User("Tom",23);
        User u2=new User("Jerry",32);
        User u3=new User("Jack",20);
        User u4=new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet=map.entrySet();
        Iterator iterator1=entrySet.iterator();
        while(iterator1.hasNext()){
            Object obj=iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry=(Map.Entry) obj;
            System.out.println(entry.getKey()+"--->"+entry.getValue());
            //User{name='Tom', age=23}--->98
            //User{name='Rose', age=18}--->100
            //User{name='Jerry', age=32}--->89
            //User{name='Jack', age=20}--->76
        }
    }

Map实现类Properties：

1）Properties类是Hashtable的子类，该对象用于处理属性文件。

2）由于属性文件里的key、value都是字符串类型，所以Properties里的key和value都是字符串类型。

3）存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法。

Properties pros=new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user=pros.getProperty("user");
System.out.println(user);

    //Properties:常用老处理配置文件，key和value都是String类型
    public static void main(String[] args){
        FileInputStream fis=null;
        try {
            Properties pros = new Properties();

            fis = new FileInputStream("jdbc.properties");
            pros.load(fis);//加载流对应的文件

            String name = pros.getProperty("name");
            String password = pros.getProperty("password");

            System.out.println("name=" + name + ",password=" + password);
            //name=Tom,password=abc123
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

//jdbc.properties
name=Tom
password=abc123

Collections工具类：

1）Collection是一个操作Set、List和Map等集合的工具类

2）Collection中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

3）操作排序：（均为static方法）

reverse(List)：反转List中的元素顺序

shuffle(List)：对List集合元素进行随机排序

sort(List)：根据元素的自然顺序对指定List集合元素按升序排序

sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

swap(List,int,int)：将指定list集合中的i出元素和j处元素进行交换

Collections常用方法：

查找、替换：

Object max(Collection)：根据元素的自然排序，返回给定集合中的最大元素

Object max(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素

Object min(Collection)：根据元素的自然排序，返回给定集合中的最小元素

Object min(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最小元素

int frequency(Collection,Object)：返回指定集合中指定元素的出现次数

void copy(List dest,List src)：将src中的内容复制到dest中

boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值

同步控制：

Collection类中提供多哦个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

import org.junit.Test;
import java.util.*;

/*
Collections:操作Collection、map的工具类
 */
public class CollectionsTest {
    @Test
    public void test1(){
        List list=new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-9);
        list.add(0);

        System.out.println(list);//[123, 43, 765, -9, 0]

        //reverse(List)：反转List中的元素顺序
        Collections.reverse(list);
        System.out.println(list);//[0, -9, 765, 43, 123]

        //shuffle(List)：对List集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);//[43, -9, 0, 123, 765]

        //sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
        Collections.sort(list);
        System.out.println(list);//[-9, 0, 43, 123, 765]h0000

        //swap(List,int,int)：将指定list集合中的i出元素和j处元素进行交换
        Collections.swap(list,1,2);
        System.out.println(list);//[-9, 43, 0, 123, 765]

        List list1=new ArrayList();
        list1.add(123);
        list1.add(43);
        list1.add(765);
        list1.add(765);
        list1.add(765);
        list1.add(-9);
        list1.add(0);

        //int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
        int frequency=Collections.frequency(list1,765);
        System.out.println(frequency);//3

        //void copy(List dest,List src)：将src中的内容复制到dest中
        List list2=new ArrayList();
        list2.add(123);
        list2.add(43);
        list2.add(765);
        list2.add(-9);
        list2.add(0);

        //错误：报异常IndexOutOfBoundsException("Source does not fit in dest")
        //List dest=new ArrayList();
        //Collections.copy(dest,list2);
        //正确的
        List dest= Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list2);
        System.out.println(dest);//[123, 43, 765, -9, 0]

        //synchronizedXxx()：
        //返回的list3即为线程安全的List
        List list3=Collections.synchronizedList(list);
    }
}

Enumeration：

Enumeration接口是Iterator迭代器的“古老版本”。

Enumeration stringEnum=new String Tokenizer("a-b*c--d-e-g","-");
while(stringEnum.hasMoreElements()){
    Object obj=stringEnum.nextElement();
    System.out.println(obbj);
}

春水煎茶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Map接口

Map接口继承树：Map：双列数据，存储key-value对的数据，类似于高中的函数：y=f(x) HashMap：作为Map的主要实现类； LinkedHashMap： TreeMap： Hashtable：作为古老的实现类； Proper...
复制链接

扫一扫