Map集合体系（HashMap，LinkedHashMap，TreeMap）-Toy模板网

这篇具有很好参考价值的文章主要介绍了Map集合体系（HashMap，LinkedHashMap，TreeMap）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.Map集合

2.hashMap集合

3.LinkedHashMap集合

4. TreeMap集合

Map集合体系（HashMap，LinkedHashMap，TreeMap）,数据结构

1.Map集合

Map集合是键值对集合

格式：{key1=value1, key2=value2, key3=value3, ...}

Map系列集合的特点都是由键决定的，值只是一个附属品，值不做要求

2.实现类有哪些？，各自有什么特点？

HashMap：无序、不重复、无索引；（用的最多）

LinkedHashMap：有序、不重复、无索引

TreeMap：按照大小默认升序排序、不重复、无索引

3.Map的常用方法

Map是双列集合的祖宗，它的功能是全部双列集合都可以继承过来使用的。

Map集合体系（HashMap，LinkedHashMap，TreeMap）,数据结构

代码展示：

package com.itheima.day08.teacher.map01;

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

public class MapDemo01 {

    /*
      Map集合是什么？有什么特点?
         Map是双列集合，也叫键值对儿集合。
            里面的元素是一对儿一对儿的。这一对儿元素称为键值对对象，Entry对象。
            当存储多个 一一对应数据的时候,使用Map。
         特点:
            键唯一,值可以重复,每个键都只能找到自己对应的值。

      Map集合实现类有哪些？
         HashMap  键 唯一 无序  无索引 值无所谓
            LinkedHashMap 键 唯一 有序  无索引 值无所谓
         TreeMap
                  键 唯一 可排序  无索引 值无所谓
      Map集合常用方法:
           集合对象的创建
           一般采用空参构造
           Map<K,V>  泛型K表示键的类型 泛型V表示值的类型
          Map<键的类型,值的类型> map =  new 子类对象<>();
           增  删  改  查
            V put(K key,V value) 存放一对元素
              put有俩层 意思
                如果 键没有在集合中出现,此时put是添加。 V返回是null.
                    键在集合中出现了,此时put是修改。 V 返回的是被替换的值。
              HashMap中是可以存储 null值 null键

             boolean isEmpty() 集合是否为空 为空true

             int size() 查看键值对个数
             clear() 清空 集合中所有键值对全删了

             查  map特点 以键为准的
               V get(K key)根据键找值
             删
               V remove(K key)根据键删除当前的键值对关系
             包含
                boolean containsKey(K k)是否包含指定的键
                boolean containsValue(V v)是否包含指定值
             获取 键集  值集
             Set<K> keySet() 获取键集
             Collection<V> values() 获取值集
           集合的遍历

     */
    public static void main(String[] args) {
        //1:创建集合对象
        Map<String,Integer> map = new HashMap<>();//多态形势下研究 通用方法
        //2:集合里面当前没有内容
        System.out.println("当前集合是不是空的呢？"+map.isEmpty());
        //3:添加键值对元素到 集合中
        map.put("随便",3);
        map.put("记忆枕",30);
        map.put("大鹅",10000);
        map.put("叮当猫",0);
        map.put("随便",4);//修改
        //4:查看集合中元素个(对)数
        System.out.println("当前集合有:"+map.size()+"对元素");
        System.out.println(map);
        //5:清空集合--
//        map.clear();
//        System.out.println(map);
        //6:根据键找值 如果找不到 返回null 找到返回对应的值。
        System.out.println("大鹅的价格:"+map.get("大鹅"));
        System.out.println("大鸦的价格:"+map.get("大鸦"));
        //7:删除
        System.out.println("删除叮当猫:"+map.remove("叮当猫"));
        System.out.println("删除之后的集合:"+map);
        //8:包含 不包含false 包含是true
        System.out.println("是否包含叮当猫的键:"+map.containsKey("叮当猫"));
        System.out.println("是否包含大鹅的键:"+map.containsKey("大鹅"));
        System.out.println("是否包含价格为30的商品:"+map.containsValue(30));
        //9:获取键集和值集
        Set<String> keys = map.keySet();
        System.out.println(keys);
        Collection<Integer> values = map.values();
        System.out.println(values);

        //10:从上面方法中选择一下  能不能完成 键值对儿数据的遍历...

    }
}

4.Map的遍历方式（三种）

        1.键找值：keySet()获取所有的键集合，在用get(),通过键获取值遍历
        2.键值对：用entrySet() ,把键值合成一个整体在set集合里，遍历用getKey()和getValue()
        3.Lambda：用forEarch，里面new BIconsumer

代码展示：

package com.itheima.day08.teacher.map01;

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

public class MapDemo02 {
    /*
      Map集合遍历方式一:
         键找值
         步骤:
            先根据keySet()方法获取键集
            遍历键集得到每个键
            根据键找值 get(K k)
     */
    public static void main(String[] args) {
        // 准备一个Map集合。
        Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精", 162.5);
        map.put("蜘蛛精", 169.8);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);//查看内容不是遍历
        //遍历指的是 一个个取出来。
        //1:获取map集合的键集
        Set<String> keys = map.keySet();
        //2:遍历 增强for 得到每个键
        for (String key : keys) {
            //3:根据键 获取对应的值
            Double value = map.get(key);
            System.out.println(key+" : "+value);
        }

    }
}


-----------------
package com.itheima.day08.teacher.map01;

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

public class MapDemo03 {
    /*
      Map集合遍历方式二:(面向对象思想方式)
        键值对儿 方式......
           键值对儿对象 叫 Entry类型
        每一个 entry对象表示 一个键值对儿
       Set<Entry对象> entrySet()  获取 "键值对儿"(整体) 集合
       Entry理解为 封装了 键和值的一个特殊对象
           getKey() 获取该对象的键
           getValue()获取该对象的值
       Entry<K,V> K键的类型 V 值的类型
        Set<Map.Entry<K,V>> entrySet()

      步骤:
         1:map集合调用 entrySet()方法 得到 一个 存放 entry对象的 set集合
         2:遍历 存放entry对象的set集合 得到每一个 entry对象
         3:调用entry对象的 获取键的方法 获取值的方法 取出对应键值
     */
    public static void main(String[] args) {
        // 准备一个Map集合。
        Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精", 162.5);
        map.put("蜘蛛精", 169.8);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);
        // 1:map集合调用 entrySet()方法 得到 一个 存放 entry对象的 set集合
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        //2：遍历 存放entry对象的set集合 得到每一个 entry对象
        for (Map.Entry<String, Double> entry : entries) {
            //entry就是存放 没对 键值的 对象
            // 3:调用entry对象的 获取键的方法 获取值的方法 取出对应键值
            String key = entry.getKey();
            Double value = entry.getValue();
            System.out.println(key+" : "+value);
        }


    }
}


------------------
package com.itheima.day08.teacher.map01;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo04 {
    /*
      Map集合遍历方式三:
         JDK8之后 Lambda方式
         map集合在JDK8之后提供类一个
            forEach(处理键和值的接口)方法

     */
    public static void main(String[] args) {
        // 准备一个Map集合。
        Map<String, Double> map = new HashMap<>();
        map.put("蜘蛛精", 162.5);
        map.put("蜘蛛精", 169.8);
        map.put("紫霞", 165.8);
        map.put("至尊宝", 169.5);
        map.put("牛魔王", 183.6);
        System.out.println(map);

        map.forEach(new BiConsumer<String, Double>() {
            @Override
            public void accept(String k, Double v) {//底层用一个方法去接收了 每次遍历出来的键和值
                System.out.println(k+" : "+v);
            }
        });
        System.out.println("================");
        map.forEach((k,v)-> System.out.println(k+" : "+v));
    }
}

2.hashMap集合

HashMap集合的底层原理

1.HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。

JDK8之前，哈希表 = 数组+链表

JDK8开始，哈希表 = 数组+链表+红黑树

哈希表是一种增删改查数据性能都较好的数据结构。

2.实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

3.HashMap如何实现键的唯一性的

依赖hashCode方法和equals方法保证键的唯一。

如果键要存储的是自定义对象，需要重写hashCode和equals方法。

代码演示：

package com.itheima.day08.teacher.map02;

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;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    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 com.itheima.day08.teacher.map02;

import java.util.HashMap;

/**
 * HashMap测试类
 */
public class HashMapDemo {

    public static void main(String[] args) {
        //创建一个 存储 学生对象--籍贯对应 关系的 集合
        HashMap<Student,String> map = new HashMap<>();
        //每次存一个学生对象--籍贯
        Student stu1 = new Student("小学", 15);
        Student stu2 = new Student("中学", 19);
        Student stu3 = new Student("高中", 22);
        Student stu4 = new Student("小学", 15);
        //stu1 来自 吉林  stu2 黑龙江  stu3 辽宁
        map.put(stu1,"吉林");
        map.put(stu2,"黑龙江");
        map.put(stu3,"辽宁");
        map.put(stu4,"热河");//  map集合特点  键唯一
             // 没有重写 hashcode equals时候  两次new 就是两个不同的对象。
             // 我们会认为 stu1 stu4 的 内容一样就是相同的对象---需要我们去重写键的hashCode equals方法

        map.forEach((k,v)->{
            System.out.println(k+"="+v);
        });
    }
}

3.LinkedHashMap集合

LinkedHashMap集合的底层原理

1.底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)。

2.实际上：原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap。

package com.itheima.day08.teacher.map02;

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;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    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 com.itheima.day08.teacher.map02;

import java.util.HashMap;
import java.util.LinkedHashMap;

/**
 * LinkedHashMap测试类
 */
public class LinkedHashMapDemo {

    public static void main(String[] args) {
        //创建一个 存储 学生对象--籍贯对应 关系的 集合
        LinkedHashMap<Student,String> map = new LinkedHashMap<>();
        //每次存一个学生对象--籍贯
        Student stu1 = new Student("小学", 15);
        Student stu2 = new Student("中学", 19);
        Student stu3 = new Student("高中", 22);
        Student stu4 = new Student("小学", 15);
        //stu1 来自 吉林  stu2 黑龙江  stu3 辽宁
        map.put(stu1,"吉林");
        map.put(stu2,"黑龙江");
        map.put(stu3,"辽宁");
        map.put(stu4,"热河");//  map集合特点  键唯一
             // 没有重写 hashcode equals时候  两次new 就是两个不同的对象。
             // 我们会认为 stu1 stu4 的 内容一样就是相同的对象---需要我们去重写键的hashCode equals方法

        map.forEach((k,v)->{
            System.out.println(k+"="+v);
        });
    }
}

4. TreeMap集合

TreeMap集合的底层原理

1.TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

2.TreeMap集合同样也支持两种方式来指定排序规则

让类实现Comparable接口，重写比较规则。

TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。

package com.itheima.day08.teacher.map02;

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;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    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 com.itheima.day08.teacher.map02;

import java.util.Comparator;
import java.util.HashMap;
import java.util.TreeMap;

/**
 * TreeMap测试类
 */
public class TreeMapDemo {

    public static void main(String[] args) {
        //创建一个 存储 学生对象--籍贯对应 关系的 集合
        TreeMap<Student,String> map = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge()-o1.getAge();
            }
        });
        //每次存一个学生对象--籍贯
        Student stu1 = new Student("小学", 15);
        Student stu2 = new Student("中学", 19);
        Student stu3 = new Student("高中", 22);
        Student stu4 = new Student("小学", 15);
        //stu1 来自 吉林  stu2 黑龙江  stu3 辽宁
        map.put(stu1,"吉林");
        map.put(stu2,"黑龙江");
        map.put(stu3,"辽宁");
        map.put(stu4,"热河");


        map.forEach((k,v)->{
            System.out.println(k+"="+v);
        });
    }
}

集合的嵌套：指的是集合中的元素又是一个集合文章来源地址https://www.toymoban.com/news/detail-833039.html

到了这里，关于Map集合体系（HashMap，LinkedHashMap，TreeMap）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！