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

HashSet

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

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遍历1

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

     }
 }

HashMap遍历2