Java集合框架详述之Map集合

百思不得小赵

发布于 2022-12-01 12:42:32

2860

发布于 2022-12-01 12:42:32

文章被收录于专栏：小赵Java总结

前言

Map接口的层次结构图：

Map集合概述

Map与Collection无继承关系。
Map集合以Key和Value的方式存储数据。（键值对）

Key和Value是引用数据类型。 Key和Value存储对象的内存地址。

所有Map集合的key特点：无序不可重复的。
Map集合的key和Set集合存储元素特点相同。

Map接口常用的方法：

void clear() 清空集合中的元素
boolean containsKey(Object key) 判断Map中是否包含某个Key
boolean containsValue(Object value) 判断Map中是否包含某个Value
V get(Object key) 通过Key获取Value
boolean isEmpty() 判断Map中元素是否为0
V put(K key, V value) 向集合中添加键值对
V remove(Object key) 通过Key删除键值对
int size() 获取Map集合中的元素个数
Collection<V> values() 获取集合Map中所有的Value，返回一个Collection

下面两个方法用于遍历Map集合：

Set<K> keySet() 获取Map所有的Key
Set<Map.Entry<K,V>> entrySet() 将Map集合转换为Set集合。

示例代码（1）：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapText01 {
    public static void main(String[] args) {
        //创建集合
        Map<Integer,String> map=new HashMap<>();
        // 向集合中添加键值对
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"lili");
        //通过Key获取Value
        String value=map.get(2);
        System.out.println(value);
        // 获取Map集合中的元素个数
        System.out.println("集合中的元素为："+map.size());
        //删除集合中的元素
        map.remove(3);
        System.out.println("集合中的元素为："+map.size());
        //判断Map中是否包含某个Key（底层调用equals方法，重写类时重写equals方法）
        System.out.println(map.containsKey(1));
        //判断Map中是否包含某个Value
        System.out.println(map.containsValue("lili"));
        //获取所有Values
        Collection<String> values=map.values();
        for(String s:values){
            System.out.println(s);
        }

        //清空集合
        map.clear();
        System.out.println("集合中的元素为："+map.size());
        //判断集合是否为空
        System.out.println(map.isEmpty());
    }
}

运行结果：

lisi
集合中的元素为：4
集合中的元素为：3
true
true
zhangsan
lisi
lili
集合中的元素为：0
true

示例代码（2）：

遍历Map集合

Set<K> keySet() 获取Map所有的Key

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapText02 {
    public static void main(String[] args) {
        //第一种方式：Set<K> keySet()  获取Map所有的Key
        Map<Integer,String> map=new HashMap<>();

        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        //遍历Map集合
        //获取所有的Key，所有的Key是一个Set集合
        Set<Integer> keys=map.keySet();
/*        //迭代器
        Iterator<Integer> it=keys.iterator();
        while (it.hasNext()){
            //取出其中的一个Key
            Integer key= it.next();
            //通过Key获取Value
            String values=map.get(key);
            System.out.println(key+"="+values);
        }*/
        //foreach
        for (Integer key:keys) {
            System.out.println(key+"="+map.get(key));
        }
    }
}

运行结果：

1=zhangsan
2=lisi
3=wangwu
4=zhaoliu

Set<Map.Entry<K,V>> entrySet() 将Map集合转换为Set集合。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapText02 {
    public static void main(String[] args) {
        //第一种方式：Set<K> keySet()  获取Map所有的Key
        Map<Integer,String> map=new HashMap<>();

        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        //遍历Map集合
        //第二种方式：Set<Map.Entry<K,V>> entrySet()  将Map集合转换为Set集合。
        Set<Map.Entry<Integer,String>> set=map.entrySet();
        /*//迭代器循环
        Iterator<Map.Entry<Integer,String>> it=set.iterator();
        while (it.hasNext()){
            Map.Entry<Integer,String> node=it.next();
            Integer key=node.getKey();
            String value=node.getValue();
            System.out.println(key+"----------->"+value);
        }*/
        //这个方法效率较高，便于开发大数据量！！
        for (Map.Entry<Integer,String> node:set) {
            System.out.println(node.getKey()+"------->"+node.getValue());
        }
    }
}

运行结果：

1------->zhangsan
2------->lisi
3------->wangwu
4------->zhaoliu

HashMap类：

HashMap底层时哈希表数据结构 -HashMap非线程安全。
放在HashMap集合Key部分的元素其实是放在HashSet中了（须重写hashCode和equals方法）

Java集合框架详述之（Collection，List，Set）

HashMap的Key部分特点：无序，不可重复。

-HashMap初始化容量为16，默认加载因子为0.75

默认加载因子表示/；当HashMap集合底层数组容量到75%时，开始扩容

扩容机制：扩容为原容量的2倍

注：HashMap集合初始化容量必须为2的倍数，因为达到散列均匀，为了提高HashMap集合存取效率。

JDK8之后新特性：

在JDK8之后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成红黑树数据结构。当红黑树上的节点数量小于6时，会重新把红黑树变成单向链表数据结构这种方式也是为了提高检索效率，二叉树的检索会再次缩小扫描范围。提高效率。

HashMap集合的key和value允许null（HashMap的key为null只能有一个）
HashMap与Hashtable区别？

HashTable的 Key和value都不可以为null HashMap的 Key和value都可以为null HashTable是线程安全的，使用较少底层也是哈希表数据结构，初始化容量为11，加载因子为0.75 扩容为：原容量*2+1;

示例代码（3）：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HasnMapText01 {
    public static void main(String[] args) {
        Map<Integer,String> map=new HashMap<>();

        map.put(1111,"wangwu");
        map.put(2222,"asdkmnc");
        map.put(3333,"king");
        map.put(4444,"zhaoliu");
        map.put(4444,"lihua");

        System.out.println(map.size());
        //遍历HashMap集合
        Set<Map.Entry<Integer,String>> set= map.entrySet();
        for (Map.Entry<Integer,String> entry:set) {
            System.out.println(entry.getKey()+"-->"+entry.getValue());
        }
    }
}

运行结果：

4
3333-->king
1111-->wangwu
4444-->lihua
2222-->asdkmnc

Properties属性类

继承Hashtable,Key和Value都是String类型
Properties是线程安全的。

Properties两个常用方法：

Object setProperty(String key, String value)存元素
String getProperty(String key) 通过key获取value

示例代码（4）：

import java.util.Properties;

public class ProperticesText01 {
    public static void main(String[] args) {
        //创建一个Properties对象
        Properties po = new Properties();
        //存元素
        po.setProperty("king", "wowowowo");
        po.setProperty("xiao", "ma");
        po.setProperty("da", "ma");
        po.setProperty("ximenqing", "www.123.com");
        //通过key获取value
        String king = po.getProperty("king");
        String xiao = po.getProperty("xiao");
        String da = po.getProperty("da");
        String ximenqing = po.getProperty("ximenqing");
        System.out.println(king);
        System.out.println(xiao);
        System.out.println(da);
        System.out.println(ximenqing);
    }
}

运行结果：

wowowowo
ma
ma
www.123.com

TreeMap类

TreeMap底层是二叉树。
无序，不可重复但是可以按照大小顺序进行排序，称为：可排序集合
放到TreeMap集合中的Key部分的元素等同于放到TreeSet集合中

示例代码（5）：

import java.util.TreeSet;

public class TreeMapText01 {
    public static void main(String[] args) {
        //
        TreeSet<String> ts=new TreeSet();
        ts.add("zhangsan");
        ts.add("wangwu");
        ts.add("make");
        ts.add("langlang");
        for (String s: ts){
            System.out.println(s);
        }
        System.out.println("=============================");
        TreeSet<Integer> ts2=new TreeSet();
        ts2.add(200);
        ts2.add(300);
        ts2.add(600);
        ts2.add(14);
        for (Integer i:ts2){
            System.out.println(i);
        }
    }
}

运行结果：

langlang
make
wangwu
zhangsan
=============================
14
200
300
600

Collections工具类

常用方法汇总：

static <T> Collection<T> synchronizedCollection(Collection<T> c) 返回由指定集合支持的同步（线程安全）集合。
static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定的Map支持的同步（线程安全）Map。
static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定的比较器指定的顺序对指定的列表进行排序。

示例代码（6）：

import java.util.*;

public class CollectionsText01 {
    public static void main(String[] args) {
        //线程不安全！！
        List<String> list=new ArrayList();
        //线程安全！！
        Collections.synchronizedList(list);

        //排序
        list.add("abc");
        list.add("abd");
        list.add("abv");
        list.add("abg");

        Collections.sort(list);
        for (String s:list){
            System.out.println(s);
        }

        //对set集合怎样排序？
        Set<String> set=new HashSet<>();

        set.add("wang");
        set.add("zheng");
        set.add("fang");
        //将Set集合转换为List集合！！！
        List<String> mylist=new ArrayList<>(set);
        //调用sort（）方法！！
        Collections.sort(mylist);
        for (String s:mylist){
            System.out.println(s);
        }
    }
}

运行结果：