Map集合及其子类相关用法

最新推荐文章于 2023-05-21 20:58:50 发布

你好y

最新推荐文章于 2023-05-21 20:58:50 发布

阅读量586

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_43430343/article/details/118529078

版权

Java基础专栏收录该内容

33 篇文章 0 订阅

订阅专栏

Map集合

概述

java.util.Map<k,v>集合

Map集合的特点：

1、Map集合是一个双列集合，一个元素包含两个值（key，value）

2、Map集合中的元素，key和value的数据类型可以相同也可以不同

3、Map集合中的元素，key是不允许重复的，但是value可以重复

4、Map集合中的元素，key和value一一对应

Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection中的集合称为单列集合，Map中的集合称为双列集合。
需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map常用子类

HashMap集合：java.util.HashMap<k,v>集合 implement Map<k,v>接口

HashMap集合的特点：

1、HashMap集合底层是哈希表：查询的速度特别的快

JDK1.8之前：数组+单向链表

JDK1.8之后：数组+单向链表/红黑树（链表长度超过8）：提高查询的速度

2、hashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

LinkedHashMap集合的特点：

java.util.LinkedHashMap<k,v>集合 implement Map<k,v>接口

1、linkedHashMap集合底层是哈希表+链表（保证迭代的顺序）

2、linkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

Map接口常用方法

public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。

返回值：v

存储键值对的时候，key不重复，返回值v是null

存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value

public V remove(Object key): 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
boolean containsKey(Object key) 判断集合中是否包含指定的键。
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map集合的遍历

方法一：通过键找值的方法遍历

实现步骤：

1、使用Map集合中的方法keySet（），把Map集合中所有的key取出来，存储到一个Set集合中

2、遍历Set集合，获取Map集合中的每一个key

3、通过Map集合中的方法get(Key)，通过key找到value

package com.itheima_01;

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

/*实现步骤：

1、使用Map集合中的方法keySet（），把Map集合中所有的key取出来，存储到一个Set集合中

2、遍历Set集合，获取Map集合中的每一个key

3、通过Map集合中的方法get(Key)，通过key找到value*/
public class MapDemo02 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("倪浩",170);
        map.put("倪浩2",160);
        map.put("倪浩3",150);
        map.put("倪浩4",70);

        //使用Map集合中的方法keySet（），把Map集合中所有的key取出来，存储到一个Set集合中
        Set<String> set = map.keySet();
        //历Set集合，获取Map集合中的每一个key
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            //通过Map集合中的方法get(Key)，通过key找到value*/
            Integer v = map.get(key);
            System.out.println(key+"+"+v);
        }

        //使用增强for来遍历
        for(String key:set){
            Integer value = map.get(key);
            System.out.println(key+"+"+value);
        }
    }
}

方法二：使用内部接口Entry

Map.Entry<k,v>:在Map接口中会有一个内部接口Entry

作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键与值的映射关系）------>相当于结婚证

实现步骤：

1、使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中

2、遍历Set集合，获取每一个Entry对象

3、使用Entry对象中的方法getKey( ) 和getValue( )获取键与值

package com.itheima_01;

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

/*实现步骤：

1、使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中

2、遍历Set集合，获取每一个Entry对象

3、使用Entry对象中的方法getKey( ) 和getValue( )获取键与值

*/
public class MapDemo03 {
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("倪浩",170);
        map.put("倪浩2",160);
        map.put("倪浩3",150);
        map.put("倪浩4",70);

        //使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //遍历Set集合，获取每一个Entry对象
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<String, Integer> entry = it.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"+"+value);
        }
        System.out.println("----");
        //使用增强for遍历
        for(Map.Entry<String,Integer> entry:set){
            String key1 = entry.getKey();
            Integer value1= entry.getValue();
            System.out.println(key1+"+"+value1);
        }
    }
}

HashMap存储自定义类型键值

package com.itheima_02;

import java.util.Objects;

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

    public Person() {
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;
        Person person = (Person) o;
        return getAge() == person.getAge() &&
                getName().equals(person.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getAge());
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

package com.itheima_02;

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

/*
* HashMap存储自定义类型键值
* Map集合保证key是唯一的：
*   作为key的元素，必须重写hashCode和equals方法
*
* */
public class HashMapDemo01 {
    public static void main(String[] args) {
        show01();
        System.out.println("----");
        show02();
    }
    /*
    HashMap存储自定义类型键值
    key:Person,要重写hashCode和equals方法，以保证key唯一
    value:String
    * */
    public static void show02(){
        //创建集合，并添加数据
        HashMap<Person,String> map1=new HashMap<>();
        map1.put(new Person("昊昊",20),"北京");
        map1.put(new Person("昊昊1",20),"北京4");
        map1.put(new Person("昊昊2",20),"北京3");
        map1.put(new Person("昊昊3",20),"北京2");
        map1.put(new Person("昊昊",20),"北京1");
        //使用entrySet和增强for循环遍历
        Set<Map.Entry<Person, String>> entrySet = map1.entrySet();
        for (Map.Entry<Person, String> entry : entrySet) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"----"+value);
            //Person{name='昊昊2', age=20}----北京3
            //Person{name='昊昊3', age=20}----北京2
            //Person{name='昊昊1', age=20}----北京4
            //Person{name='昊昊', age=20}----北京1

        }



    }
    /*
    HashMap存储自定义类型键值
    key:String类型，该类型重写了hashCode和equals方法，可以保证key唯一
    value：Person，可以重复（同名字同年龄的视为同一个人）
    * */
    public static void show01(){
        //创建集合，并添加数据
        HashMap<String,Person> map=new HashMap<>();
        map.put("北京",new Person("昊昊",20));
        map.put("上海",new Person("昊昊1",20));
        map.put("深圳",new Person("昊昊2",20));
        map.put("广州",new Person("昊昊3",20));
        map.put("北京",new Person("昊昊4",20));
        //使用keySet和增强for遍历
        Set<String> set = map.keySet();
        for (String key : set) {
            Person person = map.get(key);
            System.out.println(key+"=="+person);
            //上海==Person{name='昊昊1', age=20}
            //广州==Person{name='昊昊3', age=20}
            //北京==Person{name='昊昊4', age=20}
            //深圳==Person{name='昊昊2', age=20}
        }

    }
}

LinkedHashMap

java.util.LinkedHashMap<k,v> extends HashMap<k,v>（即k唯一，不能重复）

Map接口的哈希表和链表实现，具有可预知的迭代顺序

底层原理：哈希表+链表（记录元素的顺序），即它是有序的，元素的取出顺序和元素的存储顺序一样

HashTable

java.util.HashTable<k,v> implement Map<k,v>接口

HashTable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢

HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快

HashMap集合（之前学的所有集合）：可以存储null键，null值

HashTable集合，不能存储null键，null值

HashTable和Vector集合一样，在JDK1.2版本之后就被更先进的集合（HashMap,ArrayList）取代了

HashTable的子类Properties集合是一个唯一和IO流相结合的集合，依然活跃在历史的舞台

Map集合练习

需求：计算一个字符串中每个字符出现的次数

分析:
1.获取一个字符串对象
2.创建一个Map集合,键代表字符,值代表次数。
3.遍历字符串得到每个字符。
4.判断Map中是否有该键。
5.如果没有,第一次出现，存储次数为1 ;如果有,则说明已经出现过,获取到对应的值进行++ ,再次存储。
6.打印最终结果

package com.itheima_01;

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

/*需求：计算一个字符串中每个字符出现的次数

分析:
1.获取一个字符串对象
2.创建一个Map集合,键代表字符,值代表次数。
3.遍历字符串得到每个字符。
4.判断Map中是否有该键。
5.如果没有,第一次出现，存储次数为1 ;如果有,则说明已经出现过,获取到对应的值进行++ ,再次存储。
6.打印最终结果*/
public class MapDemo04 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s=sc.next();

        HashMap<Character,Integer> map=new HashMap<>();
        //遍历字符串得到每个字符
        for (int i = 0; i < s.length(); i++) {
            char c=s.charAt(i);
            //判断Map中是否有该键
            if(map.containsKey(c)){
                Integer integer = map.get(c);
                integer++;
                map.put(c,integer);
            }else{
                map.put(c,1);
            }

        }
        System.out.println(map);


    }
}

JDK9对集合添加的优化

jdk9新特性：

List接口，Set接口，Map接口：里面有一个静态方法of，可以给集合一次性添加多个元素
使用前提：
	当集合中存储的元素的个数已经确定了，不再改变时使用
注意：
	1、of方法只适用于List接口，Set接口，Map接口，不适用接口的实现类
	2、of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，否则会抛异常
	3、Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛异常

public class HelloJDK9 {  
    public static void main(String[] args) {  
        Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  
    }  
}

public class HelloJDK9 {  
    public static void main(String[] args) {  
        Set<String> str1=Set.of("a","b","c");  
        //str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合  
        System.out.println(str1);  
        Map<String,Integer> str2=Map.of("a",1,"b",2);  
        System.out.println(str2);  
        List<String> str3=List.of("a","b");  
        System.out.println(str3);  
    }  
}

你好y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Map集合及其子类相关用法

Map集合概述java.util.Map<k,v>集合Map集合的特点：1、Map集合是一个双列集合，一个元素包含两个值（key，value）2、Map集合中的元素，key和value的数据类型可以相同也可以不同3、Map集合中的元素，key是不允许重复的，但是value可以重复4、Map集合中的元素，key和value一一对应Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的(理解为夫妻)
复制链接

扫一扫