JAVA整數數組中，找出其中兩個數相加的和,並且找兩個目標值的下標

package cn.datamasking.test.NumSum;

import java.util.Arrays;
import java.util.HashMap;
public class Test {
    public static void main(String[] args) {
        /**
         * 查找字符串數組中是否包含指定的值
         */
        boolean resultStr = false;
        String[] arrStr = {"3", "2", "39", "6", "55", "13", "9"};
        String targetStr = "9";
        resultStr = Arrays.asList(arrStr).contains(targetStr);
        System.out.println(resultStr);

        /**
         * 整數數組中，找出其中兩個數相加的和,並且找兩個目標值的下標
         */
        int[] arrInt = {3, 2, 39, 6, 55, 13, 9};
        int targetInt = 9;
        int[] two3 = findTwoSum(arrInt, targetInt);
        for (int key : two3) {
            System.out.println(key);
        }
        /**
         * Arrays.binarySearch()方法只能用於有序數組！！！如果數組無序的話得到的結果就會很奇怪
         */
        long startTime = System.nanoTime();
        System.out.println(useArraysBinarySearch(arrStr,targetStr));
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println("useArraysBinarySearch:  " + duration / 1000000);

        /**
         * 使用循環判斷
         */
        long startTime1 = System.nanoTime();
        System.out.println(useLoop(arrStr,targetStr));
        long endTime1 = System.nanoTime();
        long duration1 = endTime1 - startTime1;
        System.out.println("useLoop:  " + duration1 / 1000000);

    }
    /**
     * 整數數組中，找出其中兩個數相加的和等於目標值的下標
     */
    public static int[] findTwoSum(int[] arrs, int target) {
        // 結果數組
        int[] result = {-1, -1};
        // 目標是數組下標，所以鍵值對爲<數值,數值對應數組下標>，這裏要說一下，哈希表的查找的時間複雜度是O(1)
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        // 1.掃描一遍數組，加入哈希表，時間複雜度是O(n)
        for (int i = 0; i < arrs.length; i++) {
            map.put(arrs[i], i);
        }
        // 2.第二次掃描，目標值-當前值，差值作爲key，看看map裏有木有，沒有就下一個循環，直到數組掃描完畢或找到value,所以最壞情況的時間複雜度是O(n)
        for (int i = 0; i < arrs.length; i++) {
            // 得到第二個數的值
            int two = target - arrs[i];
            // 如果存在第二個數的數組下標&&結果的兩個數不是同一個數的值
            if (map.containsKey(two) && target != 2 * two) {
                result[0] = i;
                result[1] = map.get(two);
                // 返回找到的兩個數的數組下標
                return result;
            }
        }
        // 沒有找到
        return result;
    }

    /**
     * 查找字符串數組中是否包含指定的值
     * *  時間複雜度劣於useLoop爲：優
     */
    public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
        int a = Arrays.binarySearch(arr, targetValue);
        if (a > 0)
            return true;
        else
            return false;
    }
    /**
     * 查找字符串數組中是否包含指定的值
     *  時間複雜度爲：優
     */
    public static boolean useLoop(String[] arr, String targetValue) {
        for(String s: arr){
            if(s.equals(targetValue))
                return true;
        }
        return false;
    }
}