Leetcode-3Sum Closest

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

    For example, given array S = {-1 2 1 -4}, and target = 1.

    The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

My Solutio :

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

public class Solution {
	public List<List<Integer>> threeSum(int[] nums) {
        HashMap<Integer, Integer> map = new HashMap<>();
        
        List<List<Integer>> ans = new ArrayList<List<Integer>>();
        
        for (int i = 0; i < nums.length; i++) {
        	map.put(nums[i], i);
        }
        
        Arrays.sort(nums);
        
        for (int i = 0; i < nums.length; i++) {
        	for (int j = i + 1; j < nums.length; j++ ) {
        		
        		int complement = - (nums[i] + nums[j]);
   
        		
        		if (map.containsKey(complement)) {
        			int complementIndex = map.get(complement);
        			if ( complementIndex != i && complementIndex != j) {
        				List<Integer> res = new ArrayList<>();
            			
            			res.add(nums[i]);
            			res.add(nums[j]);
            			res.add(complement);
            			Collections.sort(res);
            			
            			boolean isExit = false;
            			
            			for (int x = 0; x < ans.size(); x++) {
            				boolean same = true;
            				for (int y = 0; y < ans.get(x).size(); y ++) {
            					if (ans.get(x).get(y) != res.get(y)) {
            						same = false;
            						break;
            					}
            				}
            				if (same) {
            					isExit = true;
            					break;
            				}
            			}
            			
            			if(!isExit)
            			ans.add(res);
            			
        			}
        		}
        	}
        }
        
      return ans;
    }
}

Better Solution :

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.security.auth.kerberos.KerberosKey;

public class Solution2 {
	public List<List<Integer>> threeSum(int[] nums) {
		Arrays.sort(nums);
		List<List<Integer>> ans = new ArrayList<List<Integer>>();
		
		for (int i = 0; i < nums.length - 2; i++) {
			if (i > 0 && nums[i] == nums[i - 1]) {
				continue;
			}
			
			int target = - nums[i];
			int j = i + 1, k = nums.length - 1;
			
			while (j < k) {
				if (nums[j] + nums[k] == target) {
					ans.add(Arrays.asList(nums[i], nums[j], nums[k]));
					j ++;
					k --;
					
					while (j < k && nums[j] == nums[j - 1]) {
						j ++;
					} 
					while (j < k && nums[k] == nums[k + 1]) {
						k --;
					}
				} else if (nums[j] + nums[k] > target) {
					k --;
				} else {
					j ++;
				}
			}
		}
		
		return ans;
	}
}