lc哈希表（异位词|交集|快乐数|两数之和）

哈希表（又称散列表）,是根据关键码值(Key value)而直接进行访问的数据结构。

也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数散列函数，存放记录的数组叫做散列表 , 该数组里的每一个成员是一个链表的头指针（参考B站某个视频讲的杂货店例子）。

1.key.hashCode():求hash值
2.hashMap.get()方法的作用查找哈希表中对应key键的value值，如果所对应的key键在map中有映射的value值，则返回value值，否则返回null。
3.hashMap.entrySet()返回了 HashMap 中所有映射项的一个 set 集合视图, for

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
解题思路：
1.判断两个字符串是否互为字母异位词，就是在判断两个字符串中出现的字母的类型和个数是否一样。
2.判断s里面的字符(key) t中是否存在，并且他们两个的个数value需要相同。

重点：==是位运算符，equals是方法，==只是单纯判断值是否相同，引用地址的指向是否相同，而可以通过重写equals去判断对象内部

class Solution {
    public boolean isAnagram(String s, String t) {
        HashMap<Character,Integer> hashMapS=new HashMap();
        HashMap<Character,Integer> hashMapT=new HashMap();
        boolean flag=false;
        putStringInHashMap(hashMapS,s);
        putStringInHashMap(hashMapT,t);
       if(hashMapS.size()==hashMapT.size()){//判断两个字符串中出现的字母个数是否一样,遍历一个hashmap去找另外一个
        for (Map.Entry<Character, Integer> entry : hashMapS.entrySet()) {//取hashMapS的key在hashMapT中遍历
                if (hashMapT.containsKey(entry.getKey())) {//如果hashMapT有对应hashMapS的key
                    flag = hashMapT.get(entry.getKey()).equals(entry.getValue())  ? true : false;//那就去判断hashMapT中的对应key键的value值是否和hashMapS中的值相同
                    //get()返回对应key键的value值，这里的entry.getValue()返回的是hashMapS的对应key的value值
                    if (flag == false) {
                        return false;//有一个value值不同，即flag为false，直接返回false跳出循环，不需要继续判断了
                    }
                } //此时上一个if已经结束
                else {//对应的是第一个if，即 if (hashMapT.containsKey(entry.getKey())，如果key不同，也直接返回false
                    return false；
                }
            }  
            return flag;//最后返回flag
        }
        return false;//长度不等的话有不知名的多出来的字符另一个没有
    }

//putStringInHashMap记录单个元素出现的次数，如果在遍历中发现是第一次出现，
 就赋值为1，后续再查到重复的元素，就给它记录上。
 public void putStringInHashMap(HashMap<Character,Integer> hashMap,String s){
            for(int i=0;i<s.length();i++){
                if (!hashMap.containsKey(s.charAt(i))) {
                hashMap.put(s.charAt(i), 1);//没出现过计数器置为1
               }else {
                     int sum = hashMap.get(s.charAt(i)) + 1;
                     hashMap.put(s.charAt(i),sum);//在之前的基础上面加1
               }
              
            }


    }
}

346.两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

class Solution {
    /**
     * 返回nums1和nums2之间的交集
     *
     * @param nums1
     * @param nums2
     * @return
     */
    public int[] intersection(int[] nums1, int[] nums2) {
        //<num里面的字母,字母对应的下标>
        HashMap<Integer, Integer> hashMapNums1 = new HashMap<>();
        HashMap<Integer, Integer> hashMapNums2 = new HashMap<>();
        putInHash(hashMapNums1, nums1);
        putInHash(hashMapNums2, nums2);
        //返回交集数组
        ArrayList<Integer> ans = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : hashMapNums1.entrySet()) {
            if (hashMapNums2.containsKey(entry.getKey())) {
                ans.add(entry.getKey());
            }
        }
        return ans.stream().mapToInt(Integer::intValue).toArray();
        //流的形式将Arraylist转成int数组
    }

 /
    public void putInHash(HashMap<Integer, Integer> hashMap, int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            if (!hashMap.containsKey(nums[i])) {
                hashMap.put(nums[i], 1);//第一次出现
            } else {
                int sum = hashMap.get(nums[i]) + 1;
                hashMap.put(nums[i], sum);
            }
        }
    }
}

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

解题思路：无限循环代表有重复的数，当有第一个重复的数的时候就break退出循环。
1.HashSet中add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。

class Solution {
    public boolean isHappy(int n) {
    HashSet<Integer> set=new HashSet<>();
    while(n != 1 && !set.contains(n)){//当n不为1并且set中不含n
        set.add(n);//将n进行添加
        n=cal(n);
    }
    return n==1;
    }


  public int cal(int n) {
    int sum=0;
    while(n>0){//进行平方相加
    sum+=(n%10)*(n%10);
    n=n/10;
    }
   
    return sum;
}
}

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

暴力解法：

class Solution {
    public int[] twoSum(int[] nums, int target) {
    int n=nums.length;
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                return new int[]{i,j};
            }
        }
    }
        return new int[0];
    }
}

HashMap解法：

class Solution {
    /**
     * 两个数的和，输出这两个数的下标
     *
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        ArrayList<Integer> ans = new ArrayList<>();
        //<值，索引>
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (hashMap.containsKey(target - nums[i]) && (hashMap.get(target - nums[i]) != i)) {//往前看
                ans.add(hashMap.get(target - nums[i]));
                ans.add(i);
                break;
            }
            hashMap.put(nums[i], i);//<值，索引>---避免重复的key覆盖
        }
        return ans.stream().mapToInt(Integer::intValue).toArray();
    }
}