本题思路：我们只需要分别统计，字符串 s ,字符串 t 中每个字符的出现次数，分别用两个数组来存储，然后再循环遍历对比两个数组中相同位置出现的次数，如果有不同的则返回 false。

统计完之后，然后一一对比 arrayS 和 arrayT，出现次数，判断，这两个字符是有效的字母异位词

class Solution {
    public boolean isAnagram(String s, String t) {
        // 本题思路，从头到尾遍历，每个字符串中，每个字母出现的次数然后作对比，如果相同，说明字母异位词
        int lenS = s.length();
        int lenT = t.length();
        int[] arrayS = new int[123];
        int[] arrayT = new int[123];
        for(int i= 0; i < lenS ; i++){
            arrayS[s.charAt(i) - '0']++; 
        }
        for(int i = 0; i< lenT; i++){
            arrayT[t.charAt(i) - '0']++;
        }
        for(int i =0; i< arrayS.length;i++){
            if(arrayS[i] != arrayT[i]){
                return false;
            }
        }
        return true;
    }
}

本题思路：两个数组的交集，我们可以使用 set 集合，来解决这道题。首先将其中一个数组 nums1的值，存储到 set1 中，由于 set 会自动去重，所以存进去的元素是去重以后的元素。然后遍历 nums2中的所有元素，判断是否在 set1 中存在过，如果存在就存到到 set2 中。遍历完以后，set2 中存储的就是两个数组的交集。然后创建一个 ans 数组，将 set2 中元素一一赋值给 ans，最后返回 ans 数组。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 先将其中一个数组存入 set 中
        Set<Integer> set1 = new HashSet();
        for(int i = 0; i < nums1.length; i++){
            set1.add(nums1[i]);
        }
        Set<Integer> set2 = new HashSet();
        for(int i = 0; i < nums2.length; i++){
            if(set1.contains(nums2[i])){
                set2.add(nums2[i]);
            }
        }
        int[] ans = new int[set2.size()];
        int j = 0;
        for(int o : set2){
            ans[j++] = o;
        }
        return ans;
    }
}

本题思路：就是输入一个数字 n ，我们要得到 下一个数字是什么，就需要写出一个函数，来得到下个数。 得到下个数后来判断是否为1，因为题目说了，有可能无线循环，那么我们循环判断的时候，就不能只是 while (res != 1）了，在这个循环体内部，应该加入一个 Set 集合，来将每一个结果记录下来。如果出现重复就直接 返回 false，如果出了循环，说明 res=1了，直接返回 true 即可。

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet();
        int res = getNextNumber(n);
        while(res != 1){
            if(!set.contains(res)){
                set.add(res);
            }else{
                return false;
            }
            res = getNextNumber(res);
        }
        return true;
    }
        // 思路，就是输出一个数字 ，要找它的下一数，方便后续判断
    public static int getNextNumber(int n){
        int sum = 0;
        while( n != 0){
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }
}

注意：本题只要能够，写出 getNextNumber 方法，就基本完成一大半了。这个方法的逻辑，可以代代数字体会一下。

本题思路：使用 map 集合，遍历整个数组，首先将数组的第一个元素存进去 map 中，map.put(nums[0],0)，Key是 值，Value是 下标。
从下标为 1 的元素开始遍历，判断条件是 target - nums[i] 的值是否存在 map 中，
如果包含，直接返回 当前 下标，和 target - nums[i] 的下标即可。
如果不包含，则将 nums[i] 存入 map 中。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 利用 map 把所有的元素依次存入，每次存入一个判断 target - nums[i] 的值，存不存在 map中
        Map<Integer,Integer> map = new HashMap();
        map.put(nums[0],0);
        int[] res = new int[2];
        for(int i = 1; i < nums.length; i++){
            // 如果 map 中有  target - nums[i] ,说明符合题意
            if(map.containsKey(target - nums[i]) ){
                res[0] = i;
                res[1] = map.get(target - nums[i]);
                return res;
            }
            map.put(nums[i],i);
        }
        return res;
    }
}

下面用示例2，画个图来分析下这个流程，方便更加理解代码