Java中HashSet和HashMap

Set中存储元素为什么不重复(即使hashCode相同)?

 

 

 

HashSet中存放自定义类型元素时候，需要重写对象中的hashCode方法和equals方法，

HashSet中存放自定义类型元素时候，需要重写对象中的hashCode方法和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯

HashSet是单列集合

package com.biggw.day13.demo01;

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

/**
 * @author gw
 * @date 2019/11/5 0005 下午 19:04
 */

/*
 * java.util.Set接口 extends Collection接口
 * Set接口的特点:
 * 1.不允许存储重复的元素
 * 2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
 *
 * java.util.HashSet集合 implements Set接口
 * HashSet特点:
 * 1.不允许存储重复的元素
 * 2.没有索引,没有带索引的方法,也不允许使用普通的for循环遍历
 * 3.是一个无序集合,存储元素和取出元素的顺序有可能不一致
 * 4.底层是一个哈希表结构(存储速度非常快)【重要】
 *
 *
 * JDK 1.8 之前,哈希表 = 数组+链表
 * JDK 1.8及之后,哈希表 = 数组+链表(红黑树)（提高查询速度）【当链表长度超过8位,将链表改为红黑树】
 * */
public class HashSetTest {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(1);

        // 使用迭代器遍历set集合
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println("next = " + next);
        }

        // 使用增强for循环遍历set集合
        for (Integer integer : set) {
            System.out.println("integer = " + integer);
        }

        System.out.println("================");

        HashSet<String> strings = new HashSet<>();
        strings.add("重地");
        strings.add("通话");
        for (String s : strings) {
            System.out.println("s = " + s);
        }
    }
}

HashMap是双列集合

package com.biggw.day14.demo01;

import java.util.HashMap;

/**
 * @author gw
 * @date 2019/11/5 0005 下午 23:38
 */

/*
 * HashMap 的底层实现是哈希表,所以查询速度特别快
 * 1.public boolean containsKey(Object key); 判断是否含有该键,返回boolean值
 * 2.public E get(Object key); 返回键对应的值,如果不存在,返回null
 * 3.public E put(K key, V value); 添加键值对,返回添加之前的值
 * 4.public V remove(Object key); 返回移除元素对应的值
 *
 * */
public class Demo01HashMap {
    public static void main(String[] args) {
        funcPut();
        System.out.println("========");
        funcRemove();
        System.out.println("========");
        funcGet();
        System.out.println("========");
        funcContainsKey();
    }

    private static void funcContainsKey() {
        // public boolean containsKey(Object key); 判断集合中是否包含指定的值
        // 包含返回true,不包含返回false


        System.out.println("ContainsKey");
        HashMap<String, Integer> hashMap = new HashMap<>();
        // 用int类型接受,虽然我们的值是Integer类型,但是当我们第一次插入一对新键值对时候,由于键对应的值不存在,所以返回null
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);
        boolean v3 = hashMap.containsKey("小绿");
        System.out.println("v3 = " + v3);
        boolean v4 = hashMap.containsKey("小花");
        System.out.println("v4 = " + v4);

    }

    private static void funcGet() {
        // public V get(Object key)
        // 如果key存在, 返回被删除的元素
        // 如果key不存在,返回null,所以推荐使用Object接收

        System.out.println("Get");
        HashMap<String, Integer> hashMap = new HashMap<>();
        // 用int类型接受,虽然我们的值是Integer类型,但是当我们第一次插入一对新键值对时候,由于键对应的值不存在,所以返回null
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);
        Integer v3 = hashMap.get("小绿");
        System.out.println("v3 = " + v3);
        // 获取对应键对应的值
        Integer v4 = hashMap.get("小花");
        System.out.println("v4 = " + v4);
    }

    public static void funcRemove() {

        // public V remove(Object key) 把指定的键对应的值从map集合中删除,返回被删除的元素
        // 如果key存在, 返回被删除的元素
        // 如果key不存在,返回null,所以推荐使用Object接收

        System.out.println("remove");
        HashMap<String, Integer> hashMap = new HashMap<>();
        // 用Integer类型接受,虽然我们的值是int类型,但是当我们第一次插入一对新键值对时候,由于键对应的值不存在,所以返回null
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);
        System.out.println("hashMap = " + hashMap);
        Integer v3 = hashMap.remove("小白");
        System.out.println("v3 = " + v3);
        Integer v4 = hashMap.remove("小花");
        System.out.println("v4 = " + v4);
    }

    public static void funcPut() {
        // public V remove(Object key);
        // 存储键值对的时候,key不重复,返回值为null
        // 存储键值对的时候,key重复,会使用新的value替换掉map中的重复的value,并且返回被替换的value

        System.out.println("Put");
        HashMap<String, Integer> hashMap = new HashMap<>();
        // 用int类型接受,虽然我们的值是Integer类型,但是当我们第一次插入一对新键值对时候,由于键对应的值不存在,所以返回null
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);
        // 我们还可以把put理解为修改键对应的值
        Object v3 = hashMap.put("小花", 25);
        System.out.println("v1 = " + v1);
        System.out.println("v2 = " + v2);
        System.out.println("v3 = " + v3);
        System.out.println("hashMap = " + hashMap);

        /*v1 = null
        v2 = null
        v3 = 24
        hashMap = {小明=23, 小花=25}*/
    }
}

 

 HashMap遍历方法1：keySet

package com.biggw.day14.demo01;

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

/**
 * @author gw
 * @date 2019/11/6 0006 下午 13:24
 */

/*
 * Map集合中的第一种遍历方式:通过键找值进行遍历
 *
 * Map集合中的方法:
 *      public Set<K> keySet(); 返回此映射中的键的set视图
 *
 * 实现步骤:
 *      1.使用Map集合中的方法KeySet(),把Map集合中所有的key取出来,存储到一个Set集合中
 *      2.使用Set集合的迭代器方法,获取Map集合中每一个key
 *      3.通过Map集合中的方法get(key)
 *
 *
 * */
public class Demo02KeySet {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);

        Set<String> keySet = hashMap.keySet();
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println("hashMap.get(next) = " + hashMap.get(next));
        }

        for (String string : keySet) {
            System.out.println("hashMap.get(string) = " + hashMap.get(string));
        }

        for (String string : hashMap.keySet()) {
            System.out.println("hashMap.get(string) = " + hashMap.get(string));
        }
    }
}

 

HashMap遍历方法2：EntrySet

 

 

package com.biggw.day14.demo01;

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

/**
 * @author gw
 * @date 2019/11/6 0006 下午 13:53
 */

/*
* Map遍历集合的第二种方法：使用Entry对象遍历
* 
* Map集合中的方法:
*       Set<Map.Entry<K,V>> entrySet(); 返回此映射中包含的映射关系的Set视图
* 
* 实现步骤：
*       1.使用Map集合中的方法enteySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
*           Entry对象:就是键值对组合（类似夫妻组合,黄晓明和baby）
*       2.遍历Set集合,获取每一个Entry对象
*       3.使用Entry对象中的方法getKey()和getValue()获取键和值
* 
* */
public class Demo03EntryKey {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        Object v1 = hashMap.put("小明", 23);
        Object v2 = hashMap.put("小花", 24);

        Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entrySet.iterator();

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

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

    }
}