代码随想录---哈希表

HashSet----无序、不重复、无索引 

public static void main(String[] args) {
        /*
            哈希表：
                对象的整数表现形式
               1.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
               2.如果已经重写hashCode方法，不同的对象只要属性值相同，那么计算出的哈希值就是一样的
               3.在小部分的情况下，不同的属性值或者不同的地址值计算出来的哈希值有可能一样
               （称作发生哈希碰撞）
        */
        //创建对象
        Student s1 = new Student("Stella",20);
        Student s2 = new Student("Stella",20);
        //1.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
        //2.如果已经重写hashCode方法，不同的对象只要属性值相同，那么计算出的哈希值就是一样的
        System.out.println(s1.hashCode());//-229023464
        System.out.println(s2.hashCode());//-229023464

    }

 如果集合中存储的是自定义对象，必须重写HashCode和equals方法！而String、Integer内置中已经重写了无需重写。

//重写hashCode
    @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);
    }

1.有效字母异步

！！遇到需要判断⼀个元素是否出现过的场景也应该第⼀时间想到哈希表

public boolean isAnagram(String s, String t) {
        if (s.length() != t.length() || s.equals(t)) {
            return false;
        }
        int[] table = new int[26];
        for (int i = 0; i < s.length(); i++) {
            table[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            table[t.charAt(i) - 'a']--;
            if (table[t.charAt(i) - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }

hashSet只能判断一个char是否在另一个str中，无法解决重复问题 

如果s='abc',t='abb'会返回true. 

public static boolean isAnagram(String s, String t) {
        if (s.length() != t.length() || s.equals(t)) {
            return false;
        }
        Set<Integer> record = new HashSet<>(26);
        //先把s中每个char对应相对索引存入record
        for (char c : s.toCharArray()){
            record.add(c-'a');
        }
        //System.out.println(record);//[0, 1, 2, 4, 18]
        for (char c : t.toCharArray()){
            //一旦record.add(c-'a')是true，那么说明有不同的值加入，返回false
            if(record.add(c-'a')){
                return false;
            }
        }
        return true;
    }

2.两个数组的交集

        判断另一个数组中数字是否也出现，出现则放入HashSet(可以去重）

 public int[] intersection(int[] nums1, int[] nums2) {
         //为了节省运行时间，以数组中少的那个为基准
        if (nums1.length > nums2.length) {
            return intersection(nums2, nums1);
        }

        //将nums1存入hashSet中，然后遍历nums判断是否有存在，有则加入interList
        Set<Integer> interList = new HashSet<>();
        Set<Integer> baseNums = new HashSet<>();
        for(int num : nums1){
            baseNums.add(num);
        }
        for(int num : nums2){
            if(baseNums.contains(num)){
                interList.add(num);
            }
        }

        //转入数组中返回
        int[] interArr = new int[interList.size()];
        int i = 0;
        for(int num : interList){
            interArr[i] = num;
            i++;
        }
        return interArr;
    }

3.两个数组的交集II

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

        ① 使用hashMap，因为要记录值出现的次数，hashMap存储的是键值对（key,value)，key为num,value为出现次数

        ②map.getOrDefault(num, defualt)方法：得到map中num的value值，若num不存在放回defult默认值。

 public static int[] getIntersection1(int[] nums1, int[] nums2) {
        //为了节省运行时间，以数组中少的那个为基准
        if (nums1.length > nums2.length) {
            return getIntersection1(nums2, nums1);
        }
        //对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。

        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        //首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数
        for (int num : nums1) {
            int count = map.getOrDefault(num, 0) + 1;
            map.put(num, count);
        }
        int[] intersection = new int[nums1.length];
        int index = 0;
        //然后遍历第二个数组，对于第二个数组中的每个数字，
        //如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。
        for (int num : nums2) {
            int count = map.getOrDefault(num, 0);
            if (count > 0) {
                //大于零说明存在，则存入intersection
                intersection[index++] = num;
                count--;
                //‌在Java中，使用Map的put方法时，如果插入的键（key）已存在，则该方法会覆盖原有的值‌。
                //此处已存入num的相交值，并修改map原来已存入的键值对
                if (count > 0) {
                    map.put(num, count);
                } else {
                    map.remove(num);
                }
            }
        }
        return intersection;
    }