一般哈希表都是用来快速判断一个元素是否出现集合里，哈希表并不意味着一定要使用HashMap，有时候使用数组更方便，有时候要使用set，依据具体情况而定，哈希表是典型的空间换时间。
数组作为哈希表
一些应用场景就是为数组量身定做的，最常见的是要求只有小写数组，最适合用数组作为哈希表
242.有效的字母异位词
该题让我们统计两个字符串中的字符是否数量一样，都是小写字母，直接用数组来统计最合适。
/**
* 242. 有效的字母异位词 字典解法
* 时间复杂度O(m+n) 空间复杂度O(1)
*/
class Solution {
public boolean isAnagram(String s, String t) {
int[] record = new int[26];
for (int i = 0; i < s.length(); i++) {
record[s.charAt(i) - 'a']++; // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
}
for (int i = 0; i < t.length(); i++) {
record[t.charAt(i) - 'a']--;
}
for (int count: record) {
if (count != 0) { // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
return false;
}
}
return true; // record数组所有元素都为零0，说明字符串s和t是字母异位词
}
}
还有一道相似的题，与上一题的区别是a字符串中字符的数量要被b字符串包含
383. 赎金信
Set作为哈希表
力扣题目链接
349. 两个数组的交集
HashSet常用API：
- set.add() :用于往hashSet中添加元素
- set.remove():用于删除hashSet中的元素
- set.contains():用于判断这个元素在不在hashSet中
本题判断两个数组的交集，只要在一个数组中出现一次，就可以记录到hashSet中：
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
int length = nums1.length>nums2.length?nums2.length:nums1.length;
int[] result = new int[length];
int count = 0;
HashSet<Integer> set = new HashSet<>();
for (int i = 0; i < nums1.length; i++) {
if (!set.contains(nums1[i])){
set.add(nums1[i]);
}
}
for (int i = 0; i < nums2.length; i++) {
if (set.contains(nums2[i])){
result[count++] = nums2[i];
set.remove(nums2[i]);
}
}
return Arrays.copyOfRange(result,0,count);
}
}
Map作为哈希表
力扣题目链接：
1. 两数之和
HashMap常用API：
- map.put(key,value):存一个键值对
- map.get(key):根据key获取value
- map.containsKey():查找有没有对应的key
- map.getOrDefault(key,defaultValue):获得key对应的value，如果没有获得默认值
这种题目需要使用key value结构，单纯的Set已经不再适用。两数之和，存起来的key是target减去当前数组中的元素，value是对应的位置，这样到下一个元素，用当前元素的数值就可以判断有没有符合条件的结果了。
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<>();
for(int i=0;i<nums.length;i++){
if(map.containsKey(nums[i])){
int result1 = map.get(nums[i]);
return new int[]{result1,i};
}
else{
map.put(target-nums[i],i); // 如果这个不是结果，存起来，key是target-当前值，value是当前值的位置
}
}
return null;
}
}
几数之和系列
几数之和类的题目不一定适合使用哈希表，有些用双指针加去重的方式比较好。
适用于使用哈希表的题
454. 四数相加 II
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1：
输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
- (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
- (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
由于本题是在四个数组中寻找满足四个数为0的元组数，不涉及去重问题，所以可以使用HashMap，前两个数组中的和作为放入map中，value是该和的出现次数，然后在第3、4个数组中 根据两个和的负数作为key去map中查，查到了就作为结果的一部分。
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer,Integer> map =new HashMap<>();
int result=0;
for (int i:nums1){
for (int j:nums2){
map.put(i+j,map.getOrDefault(i+j,0)+1);
}
}
for (int u:nums3){
for (int v:nums4){
if (map.containsKey(-u-v)){
result+=map.get(-u-v);}
}
}
return result;
}
}
不适用哈希表，需要双指针加去重的
在几数之和类的题目中，如果是在一个数组中寻找几数之和，那么用哈希表的方法就比较麻烦，使用双指针（其实是多指针）外加考虑去重的方法是最好的。
步骤大概为：
- 将数组排序，想要后续去重，使用双指针，就一定要对数组排序。
- 遍历数组，三数之和就用一个索引外加两个指针遍历，四数之和就用两个索引外加两个指针遍历。
- 去重，每一个数都要去重，但是去重的规则是不一样的。
力扣题目：
15. 三数之和
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。
本题使用哈希表来解决并不好做，因为要考虑去重的一系列问题，所以使用双指针法。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums); // 先给数组排序
int left,right; // 两个指针，一个索引，就是共计三个指针来确定三个数
int len = nums.length;
for(int i=0;i<len;i++){
if(nums[i]>0){
return result;
}
if(i>0 && nums[i]==nums[i-1]){ // a的去重
continue;
}
left = i+1;
right = len-1;
while(left<right){
if(nums[i]+nums[left]+nums[right]<0){
left++;
} else if(nums[i]+nums[left]+nums[right]>0){
right--;
} else {
List<Integer> temp = new ArrayList<>();
temp.add(nums[i]);
temp.add(nums[left]);
temp.add(nums[right]);
result.add(temp);
while(left<right && nums[left] == nums[left+1]) left++; // b，c的去重
while(left<right && nums[right] == nums[right-1]) right--;
left++;
right--;
}
}
}
return result;
}
}
注意 a,b,c三个数的去重是有些不一样的，因为a是第一个数，要用nums[i]==nums[i-1]来判断重复，而不是判断i和i+1，就是不能判断下一个而是要判断上一个，为的就是怕（-1，-1，2）这种结果漏掉，只是结果不能重复，而不是结果里不能有重复的元素，但是b，c就没有这种限制，因为是后面的元素，如果b去重逻辑是判断i和i+1是可以的，因为c数在移动的时候会找到这个结果。不会漏掉。
力扣题目：
18. 四数之和
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
示例 1：
输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
class Solution {
// 前两个数循环，后两个数双指针，都要去重，还要注意int类型溢出的问题
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> resultList= new ArrayList<>();
Arrays.sort (nums);
int length=nums.length;
for(int i=0;i<length;i++){
if(i>0&&nums[i]==nums[i-1]){
continue;}
for (int j=i+1;j<length-2;j++){
if(j>i+1&&nums[j]==nums[j-1]){
continue;}
int left =j+1;
int right= length-1;
while (left< right){
long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
if (sum == target){
List<Integer> temp =new ArrayList<>();
temp.add(nums[i]);
temp.add(nums[j]);
temp.add(nums[left]);
temp.add(nums[right]);
resultList.add(temp);
left++;
right--;
while (left<length&&nums[left]==nums[left -1]){
left++;}
while (right>0&&nums[right]==nums[right+ 1]){
right--;
}
}
else if(sum<target){
left++;}
else{
right--;}
}
}}
return resultList;
}
}
本题需要注意的地方：
- 去重时，第二位数也是需要判断前一位而不是后一位，因为（-1，-1，-1，3）这种数可能漏判，倒数第二位和倒数第一位就不用，和三数之和同理
- 注意int类型溢出，四个int相加可能超过int类型的限制，因此转化为long类型判断
![[Android JNI] --- JNIEnv和JavaVM](https://img-blog.csdnimg.cn/cf330806f65e44e682c2a95e1be8e599.png)
