JAVA 测试总结

1.给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。范例 {1，2，3，4}  输出true

class Solution {
    public boolean containsDuplicate(int[] nums) { //将数组作为形参传入
        Arrays.sort(nums);//将数组升序
        int n = nums.length;//将数组长度赋值变量
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
}

//Arrays.sort()的作用是对括号中的数组进行排序，时间复杂度O（n*logn），方法返回值为void。 
是在原来数组的空间基础上升序，因此不需要定义一个数组接收它，即不需要返回值

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int num: nums) {
            if (set.contains(num)) {
                return true;
            }
            set.add(num);
        }
        return false;
    }
}

遍历数组，数字放到 set 中。如果数字已经存在于 set 中，直接返回 true。如果成功遍历完数组，则表示没有重复元素，返回 false

Set是一个接口，而HashSet是一个类，HashSet继承并实现了Set。
Set set  = new HashSet();创建了一个HashSet的对象后把上溯到了Set，此时它是一个Set引用
HashSet hs=new HashSet();创建一个对象保留了HashSet的所有属性，而Set的多个实现类，如LinkedSet等都无法调用
HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的无序集合，允许有 null 值
HashSer可用add()方法添加元素
contains() 方法来判断元素是否存在于集合当中，返回true/false
 remove() 方法来删除集合中的元素，返回true/false
删除集合中所有元素可以使用 clear 方法
如果要计算 HashSet 中的元素数量可以使用 size() 方法
可以使用 for-each 来迭代 HashSet 中的元素

2. 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分

范例: nums = [-2,1,-3,4,-1,2,1,-5,4]，输出6，解释：连续子数组 [4,-1,2,1] 的和最大，为 6

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

Math.max()静态的工具方法

1.当返回一组数中的最大值时，直接Math.max(10,30,20);//30

2.当返回数组中的最大值时，前面要加...,

如let arr=[1,0,2,5,3,4];

要想返回arr中的最大值，就可以直接使用Math.max(...arr),就可以返回arr中的最大值5了

3. 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

唯一想到的暴力枚举法
枚举数组中的每一个数 x，寻找数组中是否存在 target - x 
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];
    }
}

易错点: 返还类型是int[]数组，所有不能直接返回i,j，而是做成数组形式，且要new一下做成对象

哈希表方法
创建一个哈希表，对于每一个 x，首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配

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


Map 是接口 不能实例化的 ，只能使用其实现类来实例化，即Map map=new Map();是错误的。
Map map=new HashMap(); 
就是将map实例化成一个hashMap。这样做的好处是调用者不需要知道map具体的实现，map接口与具体实现的映射java帮你做了。打个比方，你是一个头头，手下有几个人：张三，李四等等。你需要手下做一件事情，你关心的是有没有人做，而不关心到底是谁去做，你只需要喊一声：“来人！”具体的是哪个人进来帮你做事无所谓。
如果说这样写： HashMap map = new HashMap();就相当于你指定要张三做事：“来张三！”就是这样。

（1）get() 方法用来获取一个 Map 对象中指定的元素。
（2）set() 方法为Map对象添加一个指定键（key）和值（value）的新元素。
（3）has() 返回一个bool值，用来表明map 中是否存在指定元素。

Map集合允许值Value对象为null，并且没有个数限制，所以当get()方法的返回值为null时，可能有两种情况，
一种是在集合中没有该键Key对象，
另一种是该键key对象没有映射任何值Value对象，即值Value对象为null。
因此，在Map集合中不应该利用get()方法来判断是否存在某个键Key，而应该利用containsKey()方法来判断

	是否继承自Collection接口	是否放入有序	是否可重复
List	是	是	是
Map	否	否	key值不可重复
Set	是	否	否

4. 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。范例:

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

最简单的方法，属于面试回家等通知的命运。。。
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
    for(int i=0;i<n;i++){
        nums1[m+i]=nums2[i];
    }
    Arrays.sort(nums1);
    }
}

数组好用的排序方法
用sort排序(升序)
int[] arr = {5,2,66,3,7};
Arrays.sort(arr);//Arrays是util包
for(int i : arr){
    System.out.println(i);//得到2，3，5，7，66 
}

双指针方法，从前向后遍历，利用上述方法未使用的 nums1与nums2已经被排序的性质
没看懂，p1,p2怎么就自增了
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;//为两个数组分别设置一个指针p1与p2来作为队列的头部指针
        int[] sorted = new int[m + n];//创建一个数组对象sorted
        int cur;//创建cur变量，防止nums1中的值被覆盖
        while (p1 < m || p2 < n) { //满足p1 < m或者要满足p2 < n，同时到达尾部才结束
            if (p1 == m) { //p1到达尾部（）
                cur = nums2[p2++]; //p2放入结果数组
            } else if (p2 == n) { //p2中的数字均大于p1中的
                cur = nums1[p1++]; //p1放入结果数组
            } else if (nums1[p1] < nums2[p2]) { //某一位置p1<p2
                cur = nums1[p1++]; //此处p1存入数组
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;
        }
        for (int i = 0; i != m + n; ++i) {
            nums1[i] = sorted[i];
        }
    }
}