[数据结构与算法]Map接口及其实现类

Map

实现类特点：都存储键值对，调用Map中的方法都一样

HashMap类

HashMap方法的使用

注意：HashMap的 Key是唯一的，Value可以重复，集合中元素无序

public static void main(String[] args) {

    HashMap<String, Integer> map = new HashMap<>();

    map.put("小明", 16);
    map.put("小强", 17);
    map.put("小红", 16);
    Integer put = map.put("小绿", 18);
    System.out.println(put);	//第一次添加key，返回null

    //清空集合
    //		map.clear();

    System.out.println("判断此集合中是否有某个key：" + map.containsKey("小明"));//true
    System.out.println("判断此集合中是否有某个value：" + map.containsValue(18));//true

    //通过key获取对应的value
    System.out.println("通过key获取对应的value：" + map.get("小红"));
    System.out.println("通过key获取对应的value：" + map.getOrDefault("小强123", 888));//能找到key，就返回对应的value，否则返回默认值888

    System.out.println("判断集合中是否没有元素：" + map.isEmpty());//false

    HashMap<String,Integer> newMap1 = new HashMap<>();
    newMap1.put("aaa", 10);
    newMap1.put("bbb", 20);
    newMap1.put("ccc", 30);
    newMap1.put("ddd", 50);
    newMap1.put("fff", 60);
    map.putAll(newMap1);//将新集合中所有的元素添加到map集合中

    //添加元素
    //如果该key存在，就返回集合中的value，否则添加k-v
    Integer put2 = map.put("bbb", 13);
    System.out.println(put2);

    //删除
    map.remove("ccc");//通过key删除映射关系
    map.remove("ddd",50);//通过key-value删除映射关系

    //替换
    //通过key替换value
    Integer replace = map.replace("aaa", 666);//通过key替换value
    System.out.println("返回替换前的value:" + replace);

    map.replace("fff", 60, 678);//通过key+value替换value

    Integer put3 = map.put("小红", 21);//添加元素，如果有相同key，就替换value，并返回
    System.out.println("返回替换前的value值：" + put3);

    //获取所有的value
    Collection<Integer> values = map.values();
    System.out.println(values);

    System.out.println("-------");
    //遍历1 - keySet()
    //遍历思路：把ConcurrentHashMap中所有的key抽取出存放在Set集合中，遍历Set集合依次取出Key，就能获取对应的Value
    Set<String> keySet = map.keySet();
    for (String key : keySet) {
        Integer value = map.get(key);//通过key获取对应的value
        System.out.println(key + " -- " + value);
    }

    System.out.println("--------------");

    //遍历2 - entrySet()
    //遍历思路：把ConcurrentHashMap中所有的映射关系(Entry)抽取出存放在Set集合中，遍历Set集合依次取出映射关系(Entry)，就能获取映射关系中的key和value
    Set<Entry<String, Integer>> entrySet = map.entrySet();
    for (Entry<String, Integer> entry : entrySet) {
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + " -- " + value);
    }
}

LinkedHashMap类

知识点：LinkedHashMap的方法使用，同上。
注意：
LinkedHashMap 的key是唯一的，value可以重复，集合中元素有序

Hashtable类

知识点：Hashtable的方法使用，同上。
注意：
Hashtable 的key是唯一的，value可以重复，，集合中元素无序

ConcurrentHashMap类

知识点：ConcurrentHashMap的方法使用，同上。
注意：
ConcurrentHashMap 的key是唯一的，value可以重复，集合中元素无序

知识点：上面四种集合的异同

• 共同点：都存储键值对，且key唯一；调用的方法一样
• 区别：
  • HashMap：无序，允许存储null，线程不安全
  • LinkedHashMap：有序，允许存储null，线程不安全
  • Hashtable：无序，不允许存储null，线程安全(直接在方法上加锁，效率低)，已弃用
  • ConcurrentHashMap：无序，不允许存储null，线程安全(局部加锁，效率高)

TreeMap类

TreeMap：对存入的元素排序，针对 key 进行排序

public static void main(String[] args) {
 /** 
	 * 特点：TreeMap针对于Key排序
	*/
    TreeMap<String, Integer> map = new TreeMap<>();

    map.put("c", 30);
    map.put("a", 39);
    map.put("d", 50);
    map.put("b", 18);

    Set<Entry<String,Integer>> entrySet = map.entrySet();
    for (Entry<String, Integer> entry : entrySet) {
        System.out.println(entry.getKey() + " -- " + entry.getValue());
    }
	//结果
//  a -- 39
//	b -- 18
//	c -- 30
//	d -- 50

}

扩展：

• HashSet底层由HashMap实现，HashSet存入的元素是存储在HashMap的Key位置上，因为HashMap的Key不允许重复
• TreeSet底层由TreeMap实现，TreeSet存入的元素是存储在TreeMap的Key位置上，因为TreeMap只针对Key才排序

//TreeSet构造方法
public TreeSet() {
     this(new TreeMap<E,Object>());
 }

//HashSet构造方法
public HashSet() {
     map = new HashMap<>();
 }

Properties类

配置文件：要写在src路径下，才能获取到

username=zhc
password=123456

public static void main(String[] args) throws IOException {
 /**
	* 知识点：Properties
	* 作用：用于配置文件
	*/
    //创建配置文件的对象
    Properties p = new Properties();
    //将配置文件加载到对象中
	p.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
    //获取配置文件中的数据
    String username = p.getProperty("username");
    String password = p.getProperty("password");
    System.out.println(username + "---" + password);//zhc---123456
}

注意

1. Collection 与 Map的区别

   Collection存储单个值，可以获取迭代器进行遍历

   Map存储两个值（键值对 key-value），不可以获取迭代器，不能遍历(Map可以间接遍历)

2. 理解Set的无序？

   Set存入顺序和取出顺序不一致，但无序不等于随机

3. ArrayList 和 LinkedList的区别

   1. 使用上的区别：

      LinkedList添加了：

      ? 队列模式 - 先进先出（removeFirst()）

      ? 栈模式 - 先进后出（removeLast()）

   2. 数据结构不同：ArrayList底层为一维数组，LinkedList底层数据结构是双向链表

   3. 效率上的区别：

      添加 - 不扩容的情况：ArrayList快（ArrayList默认初始化容量大小为10）

      添加：扩容的情况：LinkedList快

      删除：LinkedList快

      查询：ArrayList快

      修改：ArrayList快（首先查询到要修改的元素，然后才修改）

      注意：工作中常用ArrayList，因为很多需求都需要使用查询功能，ArrayList查询更快

4. 各种集合的应用场景

   • Collection接口：
     • ArrayList：存数据，线程不安全
     • LinkedList：队列模式、栈模式、线程不安全
     • Vector：弃用，线程安全
     • Stack：弃用，线程安全
     • HashSet：去重复+无序，线程不安全
     • LinkedHashSet：去重复+有序，线程不安全
     • TreeSet：排序，线程不安全
   • Map接口：
     • HashMap：存key+value，key去重，无序，线程不安全
     • LinkedHashMap：存key+value，key去重，有序，线程不安全
     • Hashtable：存key+value，key去重，无序，线程安全，分段式加锁-效率低
     • ConcurrentHashMap:存key+value，key去重，无序，线程安全，局部加锁、CAS-效率高
     • TreeMap:存key+value，针对 key 排序
     • Properties：用于配置文件