Java集合 —— Map集合

Collection接口包含List接口与Set接口
——List 元素有序（存储顺序和取出顺序一致），元素可以重复
实现List接口的三个具体类有 ArrayList，vector，linkedList
——Set 元素唯一，且元素无序（存储顺序和取出顺序不一致）
实现Set接口的两个具体类有： HashSet，TreeSet

Map集合

- - - Map接口和Collection接口的不同:
    - Map集合的特点：
    - Map集合的功能：
    - - 这里使用的具体实现类是HashMap类，其特点是
    - map集合的遍历
    - - 方式一、根据键找值，借助Set keySet()遍历
        方式二、根据键值对对象找键和值
        当自定义类的对象传入map集合时，应该重写equals和hashcode方法
    - linkedHashMap

Map接口不属于Collection接口

Map接口和Collection接口的不同:

它们两个不存在继承关系，都是属于java.util包下面的平级关系
Map集合存储的元素都是成对出现的，Map元素的键是唯一的，值是可以重复。把这样的元素理解为：夫妻对
Collection集合存储的元素都是单独出现的，Collection接口下面的Set是元素唯一的， List集合中元素是可以重复的。
这样的单独出现的元素，可以理解为单身

Map集合的特点：

将键映射到值的对象、
key和value可以是任意的引用类型的数据
一个映射不能包含重复的键（map集合的key值不能重复）
每个键最多可以映射到一个值（每个键值对只有一个key值，一个value值）
同样的值可以对应多个不同的键（不同的键值对可以拥有相同的value值）

Map集合的功能：

1、添加功能： put(K key,V value)将指定的值与该映射中的指定键相关联

2、删除功能：
remove(Object key)如果存在，从该map集合中删除一个键的映射
void clear()从该map集合中删除所有的映射

3、长度功能：int size()返回此地图中键值映射的数量

这里使用的具体实现类是HashMap类，其特点是

key值不可重复
不保证插入顺序，但是打印结果，循环遍历时，输出顺序不会改

package review.MapDemo;

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

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

        // put(K key,V value)将键值对放入map集合
        map.put("唐僧","袈裟");
        map.put("八戒","九齿钉耙");
        map.put("沙僧","行李");
        //两次插入同一个key的映射的时候，返回的是该key上一个映射中对应的值
        System.out.println(map.put("孙悟空","金箍棒")); //null
        System.out.println(map.put("孙悟空","定海神珍")); //金箍棒

        System.out.println(map.toString()); //{沙僧=行李, 孙悟空=定海神珍, 唐僧=袈裟, 八戒=九齿钉耙}

        // remove(Object key)根据key删除元素，会返回key对应的value值
        String value1 =  map.remove("沙僧");
        System.out.println(value1); //行李
        System.out.println(map.toString()); //{孙悟空=定海神珍, 唐僧=袈裟, 八戒=九齿钉耙}

		// size() 返回map集合中映射的数量
        System.out.println(map.size()); //3

        // void clear()清空map集合
        map.clear();
        System.out.println(map.toString()); //{}
    }
}

4、判断功能：
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()

package review.MapDemo;

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

public class demo2 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("唐僧","袈裟");
        map.put("八戒","九齿钉耙");
        map.put("沙僧","行李");

        //containsKey(Object key)判断集合中是否包含某个键
        System.out.println(map.containsKey("八戒")); //true
        System.out.println(map.containsKey("孙悟空")); //false

        //containsValue(Object value)判断集合中是否包含某个值
        System.out.println(map.containsValue("袈裟")); //true
        System.out.println(map.containsValue("女儿国国王")); //false

        //isEmpty()判断map集合是否为空
        System.out.println(map.isEmpty()); //false
        map.clear();
        System.out.println(map.isEmpty()); //true
    }
}

5、获取功能：
（一）get(Object key) 根据指定的key获取对应的value
（二）Set< K > keySet() 返回一个Set集合，包含map集合中全部的key值
（三）Collection< V > values() 返回一个Collection集合，包含map集合中全部的value值
（四）Set> entrySet() 返回一个Set集合，包含map集合中全部的映射关系

package review.MapDemo;

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

public class demo3 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("唐僧","袈裟");
        map.put("八戒","九齿钉耙");
        map.put("沙僧","行李");

        // get(Object key)根据指定的key获取对应的value
        //如果key值不存在，则返回null
        System.out.println(map.get("唐僧")); //袈裟
        System.out.println(map.get("女儿国国王")); //null

        //Set keySet()返回一个Set集合，包含map集合中全部的key值
        Set keys = map.keySet();
        for(String s : keys){
            System.out.println(s);
        }

        //Collection values()返回一个Collection集合，包含map集合中全部的value值
        Collection values = map.values();
        for(String s : values){
            System.out.println(s);
        }

        //Set> entrySet()返回一个Set集合，包含map集合中全部的映射关系
        Set> entrySet =  map.entrySet();
        for(Map.Entry s : entrySet){
            String key = s.getKey();
            String value = s.getValue();
            System.out.println(key+"="+value);
        }

    }
}

map集合的遍历方式一、根据键找值，借助Set keySet()遍历

package review.MapDemo;

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

public class demo4 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("孙悟空","金箍棒");
        map.put("唐僧","袈裟");
        map.put("八戒","九齿钉耙");
        map.put("沙僧","行李");

        
        //方式一，用增强for循环
        Set keys = map.keySet();
        for(String s : keys){
            String key = s;
            String value = map.get(s);
            System.out.println(key+"="+value);
        }

        //方式二，用迭代器
        //为Set集合创建一个迭代器Iterator
        Set itkeys = map.keySet();
        Iterator it = itkeys.iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

    }
}

方式二、根据键值对对象找键和值

package review.MapDemo;

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

public class demo5 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("孙悟空","金箍棒");
        map.put("唐僧","袈裟");
        map.put("八戒","九齿钉耙");
        map.put("沙僧","行李");

        
        //方式一、增强for循环
        Set> entrySet = map.entrySet();
        for(Map.Entry s : entrySet){
            String key = s.getKey();
            String value = s.getValue();
            System.out.println(key+"="+value);
        }

        //方式二、迭代器遍历
        Set> entrySet1 = map.entrySet();
        Iterator> it = entrySet.iterator();
        while(it.hasNext()){
            Map.Entry entry = it.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

结果同上面一样

当自定义类的对象传入map集合时，应该重写equals和hashcode方法

具体实现我在之前的博客写过了
集合List和Map——重写equals和hashCode方法（集合元素是类的对象）

这里举一个简单的例子

package review.MapDemo;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }
}

package review.MapDemo;

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

public class demo6 {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        Student s1 = new Student("zhang",12);
        Student s2 = new Student("zhou",14);
        Student s3 = new Student("zhang",12);
        map.put(s1,1);
        map.put(s2,2);
        map.put(s3,3);

        Set keys = map.keySet();
        for(Student s : keys){
            String name = s.getName();
            int age = s.getAge();
            System.out.println(name+"---"+age);
        }
    }
}

linkedHashMap

实现了Map接口，底层是依赖于哈希表和链表的，具有可预知的遍历顺序
哈希表保证唯一性，保证的是Key的唯一性
链表保证有序，保证的是键的有序（存储和取出顺序一致）

package review.MapDemo;

import java.util.linkedHashMap;
import java.util.Set;

public class linkedHashMapDemp1 {
    public static void main(String[] args) {
        linkedHashMap map = new linkedHashMap<>();
        map.put("1","java");
        map.put("3","hive");
        map.put("2","hadoop");

        Set keys = map.keySet();
        for(String s : keys){
            String key = s;
            String value = map.get(s);
            System.out.println(key+"="+value);
        }
    }
}

Java集合 —— Map集合

Java相关栏目本月热门文章