• 查找两数之和是不是等于target
• 也就是我们找到一个数之后，用target将其减掉，再寻找应当对应的元素是什么
• 每找到一个数，我们就将其放在集合中，因为集合中可以去重，保证我们只遍历过一次，然后再继续遍历数组，将target减去当前的数组中的值，看看已经遍历过的数组中是不是有该值，有的话就加入返回结果。
• 没有的话就将其加入。

思想：用集合存放遍历过的数值，然后根据当前定位到的数值，判断自己寻找的数值在集合中是否出现，若出现就返回结果。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        Map<Integer,Integer> map = new HashMap<>();
        if(nums.length == 0 || nums == null){
            return res;
        }
        for(int i = 0;i < nums.length;i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[0] = map.get(temp);
                res[1] = i;
            }else{
                map.put(nums[i],i);
            }
        }
        return res;
    }
}

思想：如果可以重组后构成一个单词，那么可以把字符串先转换成字符数组，然后对字符数组中的字母进行排序。将排序过后的字符数组转换成字符串，然后再作为键出现。然后把键一样的值添加到该键对应的列表当中即可。如果没有改键，那就创建一个新的链表，并同时把键值对插入进去。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String,List<String>> map = new HashMap<>();
        for(String str : strs){
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key,new ArrayList<>());
            list.add(str);
            map.put(key,list);
        }
        return new ArrayList<List<String>>(map.values());
    }
}

思想：遍历该数组，当遍历到的元素，在该集合中有前驱的时候就跳过。也就是说，遍历到的数字必须是该序列中第一个打头的才进行处理和操作。并且要记录是当前数字打头的连续序列更长还是已经记录的旧的更长。

class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> sets = new HashSet<>();
        for(int num : nums){
            sets.add(num);
        }
        int maxLong = 0;
        for(int set : sets ){
            int num = set;
            if(!sets.contains(num - 1)){
                int curLong = 1;

                while(sets.contains(num+1)){
                    num++;
                    curLong++;
                }

                maxLong = Math.max(curLong,maxLong);
            }
        }
        return maxLong;
    }
}

思想：使用双指针法进行求解，左指针先不动，指向已经处理好的序列的尾部，右指针寻找不为零的时候，如果不为零，就和left指向的元素进行交换。到最后，left之前的数组就都是不为零的，且位置没有被改变。

class Solution {
    public void moveZeroes(int[] nums) {
        int left = 0, right = 0,len = nums.length;
        while(right < len){
            if(nums[right] != 0){
                int temp = nums[right];
                nums[right] = nums[left];
                nums[left++] = temp;
            }
            right++;
        }
    }
}