欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Java容器-Map接口

程序员文章站 2022-06-16 23:37:54
...

1. Map 接口特点

Map 接口定义了双例集合的存储特征，它并不是 Collection 接口的子接口。双例集合的存储特征是以 key 与 value 结构为单位进行存储。
Map 与 Collecton 的区别：

  1. Collection 中的容器，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
  2. Map 中的容器，元素是成对存在的(理解为现代社会的夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
  3. Collection 中的容器称为单列集合，Map 中的容器称为双列集合。
  4. Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
  5. Map 中常用的容器为 HashMap，TreeMap 等。

2. Map 的常用方法

方法 说明
V put (K key,V value) 把 key 与 value 添加到 Map 集合中
void putAll(Map m) 从指定 Map 中将所有映射关系复制到此 Map 中
V remove (Object key) 删除 key 对应的 value
V get(Object key) 根据指定的 key，获取对应的 value
boolean containsKey(Object key) 判断容器中是否包含指定的 key
boolean containsValue(Object value) 判断容器中是否包含指定的 value
Set keySet() 获取 Map 集合中所有的 key，存储到 Set 集合中
Set<Map.Entry<K,V>> entrySet() 返回一个 Set 基于 Map.Entry 类型包含 Map 中所
有映射
void clear() 删除 Map 中所有的映射

3. HashMap 容器类

HashMap 是 Map 接口的接口实现类，它采用哈希算法实现，是 Map 接口最常用的实现类。 由于底层采用了哈希表存储数据，所以要求键不能重复，如果发生重复，新的值会替换旧的值。 HashMap 在查找、删除、修改方面都有非常高的效率。

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

public class HashMapTest01 {
    public static void main(String[] args) {
        //实例化HashMap容器
        Map<String, String> map = new HashMap<>();
        //添加元素
        map.put("username", "张三");
        map.put("age", "18");
        map.put("sex", "男");
        String value = map.put("username", "李四");
        System.out.println(value);  //张三    返回被覆盖的value
        System.out.println(map);    //{sex=男, age=18, username=李四}

        //获取元素
        String val = map.get("username");
        System.out.println(val);    //李四

        //获取HashMap中所以的元素，可以使用 keySet 方法与 get 方法一并完成
        Set<String> keys = map.keySet();
        for (String key: keys){
            String val2 = map.get(key);
            System.out.println(key + "----" + val2);
        }

        //通过entrySet方法获取Map.Entry类型获取元素
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for (Map.Entry<String,String> entry: entrySet){
            String key = entry.getKey();
            String val3 = entry.getValue();
            System.out.println(key + "----" + val3);
        }

        //删除元素
        String val4 = map.remove("age");    //返回被删除元素的value

        //判断key或value是否存在
        boolean flag1 = map.containsKey("username");
        boolean flag2 = map.containsValue("20");
		-----------------------------------------------------------------
		//实例化HashMap容器
        Map<String, String> map = new HashMap<>();
        map.put("username", "张三");
        map.put("age", "18");
        map.put("sex", "男");

        Map<String, String> map2 = new HashMap<>();
        map2.put("id", "1001");
        map2.put("age", "20");
        //Map容器的并集操作
        map.putAll(map2);
        Set<String> keys = map.keySet();
        for (String key: keys){
            System.out.println(key+"====" + map.get(key));
        }
    }
}

4. TreeMap 容器类

TreeMap 和 HashMap 同样实现了 Map 接口，所以，对于 API 的用法来说是没有区别的。HashMap 效率高于 TreeMap；TreeMap 是可以对键进行排序的一种容器，在需要对键排序时可选用 TreeMap。TreeMap 底层是基于红黑树实现的。
在使用 TreeMap 时需要给定排序规则（同TreeSet）：

  1. 元素自身实现比较规则
  2. 通过比较器实现比较规则

5. 迭代器的使用

5.1 Iterator 迭代器接口介绍

Collection接口继承了Iterable接口，在该接口中包含一个名为iterator的抽象方法，所有实现了Collection接口的容器类对该方法做了具体实现。iterator方法会返回一个Iterator接口类型的迭代器对象，在该对象中包含了三个方法用于实现对单例容器的迭代处理。
Iterator对象的工作原理：
Java容器-Map接口
Iterator接口定义了如下方法：

  1. boolean hasNext(); //判断游标当前位置是否有元素，如果有返回true，否则返回false；
  2. Object next(); //获取当前游标所在位置的元素，并将游标移动到下一个位置；
  3. void remove(); //删除游标当前位置的元素，在执行完next后该操作只能执行一次；

5.2 迭代器的使用

5.2.1 使用 Iterator 迭代 List 接口类型容器

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorListTest {
    public static void main(String[] args) {
        //实例化容器
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        //获取元素
        //方式一:在迭代器中，通过while循环获取元素
        //获取迭代器对象
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String value = iterator.next();
            System.out.println(value);
        }

        System.out.println("--------------------------------");
        //方法二：在迭代器中，通过for循环获取元素
        for (Iterator<String> it = list.iterator();it.hasNext();){
            String value = it.next();
            System.out.println(value);
        }
    }
}

5.2.2 使用 Iterator 迭代 Set 接口类型容器

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class IteratorSetTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("a");
        set.add("b");
        set.add("c");

        //获取元素
        //方式一：通过 while 循环
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("-----------------------");
        //方式二：通过 for 循环
        for (Iterator<String> it = set.iterator();it.hasNext();){
            System.out.println(it.next());
        }
    }
}

5.2.3 在迭代器中删除元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorRemoveTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            //不要在一次循环中多次调用next方法
            String value = iterator.next();
            if (value.equals("c")){
                iterator.remove();
            }
        }
        //等价于
        //list.removeIf(value -> value.equals("c"));
    }
}

6. Collections 工具类

Collections 是一个工具类，它提供了对 Set、List、Map 进行排序、填充、查找元素的辅助方法。该类中所有的方法都为静态方法。
常用方法：

  1. void sort(List) //对 List 容器内的元素排序，排序的规则是按照升序进行排序。
  2. void shuffle(List) //对 List 容器内的元素进行随机排列。
  3. void reverse(List) //对 List 容器内的元素进行逆续排列 。
  4. void fill(List, Object) //用一个特定的对象重写整个 List 容器。
  5. int binarySearch(List, Object)//对于顺序的 List 容器，采用折半查找的方法查找特定对象。

6.1 对 List 类型容器进行排序处理

import java.util.*;

public class CollectionTest01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("c");
        list.add("b");
        list.add("d");
        list.add("a");
        //通过 Collections 工具类中的 sort 方法完成排序
        Collections.sort(list);
        for(String str:list){
            System.out.println(str);
        }
    }
}

6.2 对 List 类型容器进行随机排序

List<String> list2 = new ArrayList<>();
list2.add("a");
list2.add("b");
list2.add("c");
list2.add("d");
//洗牌处理
Collections.shuffle(list2);
for(String str:list2){
   	System.out.println(str);
}
相关标签： java java hashmap

上一篇： Map与HashMap,Hashtable,HashSet的区别

下一篇： 【leetcode】378. Kth Smallest Element in a Sorted Matrix

推荐阅读