Leetcode 349 两个数组的交集 （*哈希数组，*HashSet，*HashMap）

---------------🎈🎈题目链接🎈🎈-------------------

解法1 [用数组构建hashmap] 😋

自己的笨比方法:【哇这居然是标准解法之一，我不是笨比😋😋😋】
创建了两个hash数组，nums1出现一个就对应位置变为-1，nums2出现一个对应位置就为-1，之后如果nums1[m]+nums2[m]
== -2，则说明是交集，使用arr.add()加到末尾，最后再将ArrayList 转化为int[ ] 数组

// ArrayList<Integer> 转化为int[ ] 数组
int[] array = new int[arr.size()];
for(int i = 0; i < arr.size(); i++){
    array[i] = arr.get(i);
}

时间复杂度O(N)
空间复杂度O(N)

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 数组作为hash表
        ArrayList<Integer> arr = new ArrayList<>();
        int[] hash1 = new int[1001];
        int[] hash2 = new int[1001];
        
 
        for(int i = 0; i < nums1.length; i++){
            hash1[nums1[i]] = -1;
        }
        for(int j = 0; j < nums2.length; j++){
            hash2[nums2[j]] = -1;
        }
         for(int m = 0; m <= 1000; m++){
            if(hash1[m]+hash2[m] == -2){
                arr.add(m);
            }
        }

        int[] array = new int[arr.size()];
        for (int i = 0; i < arr.size(); i++) {
            array[i] = arr.get(i);
        }
        return array;
    }
}  

HashSet and .HashMap

1.HashSet

import java.util.HashSet

HashSet和HashMap是Java集合框架中的两个不同的类，用于存储和操作数据。

HashSet是一个基于哈希表的集合实现，它实现了Set接口。它使用哈希表来存储元素，不允许重复元素，并且不保证元素的顺序。HashSet提供了高效的插入、删除和查找操作，时间复杂度为O(1)。它适用于需要快速查找和去重的场景。

以下是HashSet的一些常用操作方法：
- add(element)：向集合中添加元素。
- remove(element)：从集合中移除指定元素。
- contains(element)：判断集合中是否包含指定元素。
- size()：返回集合中元素的数量。

2.HashMap

HashMap是一个基于哈希表的键值对存储实现，它实现了Map接口。它使用哈希表来存储键值对，其中每个键都是唯一的。HashMap提供了高效的插入、删除和查找操作，时间复杂度为O(1)。它适用于需要根据键快速查找和操作值的场景。

以下是HashMap的一些常用操作方法：
- put(key, value)：将键值对添加到映射中。
- get(key)：根据键获取对应的值。
- remove(key)：根据键移除对应的键值对。
- containsKey(key)：判断映射中是否包含指定的键。
- containsValue(value)：判断映射中是否包含指定的值。
- size()：返回映射中键值对的数量。

总结来说，HashSet用于存储唯一的元素集合，而HashMap用于存储键值对映射。它们都提供了高效的操作方法，但在使用时需要根据具体的需求选择合适的集合类型。

解法2 [使用HashSet]⭐️

时间复杂度O(N)
空间复杂度O(N)

⭐️【HashSet】无序不重复
import java.util.HashSet；
新建Hashset：Hashset<Integer> hashset = new HashSet<>();
Hashset存在元素：hash.contains();
Hashset添加元素：hash.add();
取Hashset中的元素：增强型for循环 for(int index num : hashset){ }
Hashset的大小：hashset.size()

将HashSet转化为int[ ]：
方法1：return resSet.stream().mapToInt(x -> x).toArray(); 这行代码使用了 Java 8 中的流式操作来将 HashSet 转换为 int[] 数组。
方法2：增强型for循环遍历hashset中元素，弄到数组中，原因是hashset无序

int index = 0;
for(int num : hashset2){ // 使用【增强型for循环遍历hashset中元素，弄到数组中，原因是hashset无序】
     res[index++] = num;
}

解释这行代码的步骤如下：

1. resSet.stream() 将 HashSet 转换为一个流（Stream）对象。
2. mapToInt(x -> x) 将流中的每个元素映射为 int 类型。这里的 x -> x 是一个 lambda 表达式，表示对每个元素不进行任何操作，直接返回原值。
3. toArray() 将流中的元素收集到一个数组中。

最终，这行代码返回的是一个 int[] 数组，其中包含了 HashSet 中的元素。

请注意，使用流式操作可以简化代码，并且在一行中完成转换操作。但是，这种方式可能会对性能产生一定的影响，因为涉及到了流的创建和操作。在处理大量数据时，可能需要考虑性能方面的问题。

import java.util.HashSet;
import java.util.Arrays;


class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 新建2个hashset 内不含重复元素，但不保证顺序
        HashSet<Integer> hashset1 = new HashSet<>();
        HashSet<Integer> hashset2 = new HashSet<>();

        // 将nums1数组中的元素添加到hashset1中
        for(int i = 0; i < nums1.length; i++){
            hashset1.add(nums1[i]);
        }

        // 遍历nums2数组，如果元素在set1中存在，则将元素添加到hashset2中
        for(int i = 0; i < nums2.length; i++){
            if(hashset1.contains(nums2[i])){
                hashset2.add(nums2[i]);
            }  
        }

        // 将set转化为int[]数组输出
        int[] res = new int[hashset2.size()];
        int index = 0;
        for(int num : hashset2){ // 使用【增强型for循环遍历hashset中元素，弄到数组中，原因是hashset无序】
            res[index++] = num;
        }
        return res;

    }
}