题目：
/*
* 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
 *
 * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
 *
 *  
 *
 * 示例:
 *
 * 给定 nums = [2, 7, 11, 15], target = 9
 *
 * 因为 nums[0] + nums[1] = 2 + 7 = 9
 * 所以返回 [0, 1]
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode-cn.com/problems/two-sum
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */

　　我的做法： O(n2)

    public static int[] twoSum(int[] nums, int target) {
//        int b[] =new int [2];
//        //1.使用双重for循环来遍历数组
//        boolean flag=true;
//        for(int i=0;i<nums.length;i++){
//            if(flag){
//                for (int j=i+1;j<nums.length;j++){
//                    int sum=nums[i]+nums[j];
//                    if(sum==target){
//                        flag=false;
//                        b[0]=i+1;
//                        b[1]=j+1;
//                        break;
//                    }
//                }
//            }
//        }
//        return b;

　　

 

大神的做法：O(n)

 /* 大佬的思路
             * 1.将target-a[i]的值判断是否在Hashtable中，如果在就返回位置
             * 2.如果不再，装载进HashTable中
             *
             * 例如  {2 7 8 9} 9
             * 第一次判断 9-2=7，HashTable中是否包含有7，没有7，HashTable.put(2(value),0(index))
             * 第二次判断 9-7=2，HashTable中是否包含2 包含 则返回数组7和HashTable key=2的索引值*/


            Hashtable<Integer,Integer> hashtable=new Hashtable();
            for(int i=0;i<nums.length;i++){
//             if(hashtable.containsKey(target-nums[i])){
               if(hashtable.contains(target-nums[i])){
                   int a=hashtable.get(2);
                   return new int[]{i,hashtable.get(target-nums[i])};
               } else{
                   hashtable.put(i,nums[i]);
               }
            }
            return null;

　　

精妙之处在于：大佬使用了HashTable，在检索的时候使用的key-value的检索。而我使用的for循环检索，index-value的检索。

这里也可以将HashTable替代成HashMap。

 

总结：在检索的时候，尽量使用Key-value来代替遍历检索

 

我第二次做这个题目的时候,使用了以下的代码

 public static int[] getIndex(int[] param,int target){
        List list=new ArrayList<>();
        int [] arr=new int[2];
        //1.return arrays to map(index,context)
        for (int i = 0; i <param.length ; i++) {
            list.add(param[i]);
        }
        int prepare=-1;
        int retNum=-1;
        int i;
        for( i=0; i <param.length ; i++){
            prepare=(int)list.get(i);
            int chazhi=target-prepare;
            if(list.contains(chazhi)){
                retNum= list.indexOf(chazhi);
                break;
            }
        }
        arr[0]=i;
        arr[1]=retNum;
        return arr;
    }

　　思想上确实有转变