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

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

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

输入：
[2,7,11,15]
9
预期结果
[0,1]

方法一：暴力枚举

  1. class Solution {
  2.     public int[] twoSum(int[] nums, int target) {
  3.         int n = nums.length;
  5.         //枚举数组中的每一个数 x，寻找数组中是否存在 target - x
  6.         for (int i = 0; i < n; ++i) {
  7.             for (int j = i + 1; j < n; ++j) {
  8.                 if (nums[i] + nums[j] == target) {
  9.                     return new int[]{i, j};
  10.                     //new关键字被使用来创建一个新的对象，可以理解为创建的意思。
  11.                     //使用关键字new来创建一个对象也叫类的实例化，使用new创建对象时，会调用构造方法初始化对象
  12.                 }
  13.             }
  14.         }
  16.         return new int[0];
  17.     }
  18. }

方法二：哈希表

  1. class Solution {
  2.     public int[] twoSum(int[] nums, int target) {
  3.         Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
  4.         //HashMap的默认容量是16
  5.             //当在进行put的时候，插入的元素超过了容量（由加载因子决定）的范围就会触发扩容操作，也就是rehash过程
  6.             //这个方法会重新将原数组的内容重新hash到新的扩容数组当中
  8.         for (int i = 0; i < nums.length; ++i) {
  9.             if (hashtable.containsKey(target - nums[i])) {
  10.                 //public boolean containsKey(Object key)
  11.                 //如果Hashtable中存在与指定的key，则此方法返回true，否则返回false。
  12.                 return new int[]{hashtable.get(target - nums[i]), i};
  13.                 //public V get(Object key)
  14.                 //根据key获取value对象
  15.             }
  16.             hashtable.put(nums[i], i);
  17.             //public V put(K key, V value)
  18.             //在Hashtable中插入具有指定键的指定值
  19.         }
  20.         return new int[0];
  21.     }
  22. }

hashtable.containsKey(Object key)

如果Hashtable中存在与指定的key，则此方法返回true，否则返回false

hashtable.get(Object key)

根据key获取value对象

hashtable.put(K key, V value)

在Hashtable中插入具有指定键的指定值