Map集合

  • Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
  • Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。
  • Collection中的集合称为单列集合,Map中的集合称为双列集合。
  • 需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。
    在这里插入图片描述
    在这里插入图片描述
    Map接口中的常用方法
import java.util.HashMap;

/* `public V put(K key, V value)`:  把指定的键与指定的值添加到Map集合中。
 * `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集合)。
* */
public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        map.put("Seven",20);
        System.out.println(map);
        map.remove("Seven");
        System.out.println(map);
        Integer xn = map.get("谢娜");
        System.out.println(xn);
        boolean zyz = map.containsKey("赵雅芝");
        System.out.println(zyz);
    }
}

在这里插入图片描述
Map集合遍历键找值方式

键找值方式:即通过元素中的键,获取键所对应的值

分析步骤:

  1. 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示:keyset()
  2. 遍历键的Set集合,得到每一个键。
  3. 根据键,获取键所对应的值。方法提示:get(K key)
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;


public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        Set<String> set=map.keySet();
        //迭代器方法
        Iterator<String> it=set.iterator();
        while(it.hasNext()){
            String key=it.next();
            Integer value = map.get(key);
            System.out.println(value);
        }
        //增强for
        for(String key:set){
            System.out.println(map.get(key));
        }
    }
}

Entry键值对对象
键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。
操作步骤与图解:

  1. 获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示:entrySet()
  2. 遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。
  3. 通过键值对(Entry)对象,获取Entry对象中的键与值。 方法提示:getkey() getValue()
    在这里插入图片描述
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class test {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("赵丽颖",18);
        map.put("赵雅芝",60);
        map.put("谢娜",20);
        Set<Map.Entry<String, Integer>> entry = map.entrySet();

        Iterator<Map.Entry<String,Integer>> it= entry.iterator();

        while(it.hasNext()){
            Map.Entry<String, Integer> a = it.next();
            String key = a.getKey();
            Integer value = a.getValue();
            System.out.println(key+"..."+value);
        }

        for(Map.Entry<String,Integer> entry1:map.entrySet()){
            Integer value = entry1.getValue();
            String key = entry1.getKey();
            System.out.println(key+"..."+value);
        }
    }
}

HashMap存储自定义类型键值

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class test {
    public static void main(String[] args) {
        //show01();
        show02();
    }

    private static void show02() {
        HashMap<Person,String> map=new HashMap<>();
        map.put(new Person("张三",18),"北京");
        map.put(new Person("李四",19),"上海");
        map.put(new Person("王五",20),"广州");
        map.put(new Person("张三",18),"北京");
        Set<Map.Entry<Person, String>> set = map.entrySet();
        for(Map.Entry<Person,String> entry:set){
            Person key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"--->"+value);
        }
    }

    private static void show01() {
        HashMap<String,Person> map=new HashMap<>();
        map.put("北京",new Person("张三",18));
        map.put("上海",new Person("李四",19));
        map.put("广州",new Person("王五",20));
        map.put("北京",new Person("赵六",18));
        Set<String> set = map.keySet();
        for(String key:set){
            Person value=map.get(key);
            System.out.println(key+"--->"+value);
        }
    }
}

我们知道HashMap保证成对元素唯一,并且查询速度很快,可是成对元素存放进去是没有顺序的,那么我们要保证有序,还要速度快怎么办呢?
在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构。

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

public class test {
    public static void main(String[] args) {
        HashMap<String,String> map=new HashMap<>();
        map.put("a","b");
        map.put("c","b");
        map.put("b","b");
        map.put("a","d");
        System.out.println(map);//key不允许重复,无序 {a=d, b=b, c=b}

        LinkedHashMap lin=new LinkedHashMap();
        lin.put("a","b");
        lin.put("c","b");
        lin.put("b","b");
        lin.put("a","d");
        System.out.println(lin);//key不允许重复,有序 {a=d, c=b, b=b}
    }
}

Hashtable
在这里插入图片描述
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值