Return to Answer

 public static int[] findTwoSum(int[] numbers, int target) {
 int[] numbersSorted = Arrays.copyOf(numbers, numbers.length);
 Arrays.sort(numbersSorted);

 List<Integer> numberPair = new ArrayList<>();
 for (int i = 0; i < numbersSorted.length && numbersSorted[i] <= target / 2; i++) {
 int j = Arrays.binarySearch(
 numbersSorted,
 i + 1,
 numbersSorted.length,
 target - numbersSorted[i]);
 if (j >= 0) {
 numberPair.add(numbersSorted[i]);
 numberPair.add(numbersSorted[j]);
 break;
 }
 }
 /* The numbers themselves are found, now get their
 indices in the original array */
 if (numberPair.isEmpty()) {
 return null;
 } else {
 assert numberPair.size() == 2;
 List<Integer> originalIndexes = new ArrayList<>();
 for (int i = 0; i < numbers.length && originalIndexes.size() < 2; i++) {
 if (numberPair.contains(numbers[i])) {
 originalIndexes.add(i);
 numberPair.remove(Integer.valueOf(numbers[i]));
 /* ^
 explicit boxing necessary, otherwise
 List.remove(int) will be called
 */
 }
 }

 assert originalIndexes.size() == 2;
 assert numberPair.isEmpty();

 return new int[]{originalIndexes.get(0), originalIndexes.get(1)};
 }
 }

This basically does what you presumably intended to do originally, but since it takes advantage of native methods like the binary search algorithms, it is probably much faster than your original code.

 /**
 * A helper class to facilitate the use of the binary search methods of the
 * {@code Arrays} class when searching for an {@code int} in an array where
 * every number of that array is bound to another {@code int} (in this case,
 * an index in another, unsorted array).
 */
 private static class NumberWithIndex implements Comparable<NumberWithIndex> {
 /**
 * This field is non-final so that a search template can be used and a
 * new object does not have to be created for every search
 */
  private int number;

 /**
 * This field is ignored in equals, hashCode and compareTo
 */
 private final int index;

 NumberWithIndex(int number, int index) {
  this.number = number;
 this.index = index;
 }
  void setNumber(int number) {
 this.number = number;
  }
 int getNumber() {
 return number;
  }
 int getIndex() {
 return index;
  }

 @Override
  public int hashCode() {
 return number;
 }
 @Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
  if (!(obj instanceof NumberWithIndex)) {
 return false;
  }
 final NumberWithIndex other = (NumberWithIndex) obj;
 return this.number == other.number;
 }
 @Override
 public int compareTo(NumberWithIndex o) {
 return this.number - o.number;
 }
 }
  public static int[] findTwoSum(int[] numbers, int target) {
  NumberWithIndex[] numbersWithOriginalIndexesSorted = new NumberWithIndex[numbers.length];
 for (int i = 0; i < numbers.length; i++) {
 numbersWithOriginalIndexesSorted[i] = new NumberWithIndex(numbers[i], i);
  }
 Arrays.sort(numbersWithOriginalIndexesSorted);
 NumberWithIndex searchTemplate = new NumberWithIndex(0, 0);
 // index of searchTemplate is irrelevant, 0 is completely arbitrary
 for (int i = 0;
 i < numbersWithOriginalIndexesSorted.length
 && numbersWithOriginalIndexesSorted[i].getNumber() <= target / 2;
 i++) {
 searchTemplate.setNumber(target - numbersWithOriginalIndexesSorted[i].getNumber());
 int j = Arrays.binarySearch(
 numbersWithOriginalIndexesSorted,
 i + 1,
 numbersWithOriginalIndexesSorted.length,
 searchTemplate);

 if (j >= 0) {
  return new int[]{
  numbersWithOriginalIndexesSorted[i].getIndex(),
  numbersWithOriginalIndexesSorted[j].getIndex()
 };
 }
 }
 return null;
 }

This basically does what you presumably intended to do originally, but since it takes advantage of native methods like the binary search algorithms, it is probably much faster than your original code.

Update

I've refined the code that demonstrates the usage of the binary search algorithm provided by the Arrays class. Instead of simply creating a copy of the original array, sorting that copy, finding a number pair from that sorted copy and then iterating through the original array to get the indexes, the updated code binds the original indexes to the numbers prior to sorting them. Unfortunately, this cannot be done with a Map.Entry<Integer, Integer>, because then it would not be possible to use the binary search methods in Arrays, since, for one thing, a Map.Entry is not comparable, and for another, its equals(Object) method also takes into account the entry's value, which in our case would represent the index in the original array, which is irrelevant when just searching for the numbers. It is therefore necessary to design a helper class that ignores the index the numbers are bound to in its equals and compareTo methods. This might seem convoluted, but from a purely programming-logical point of view, this is the most elegant solution I can think of for your algorithm (note that there might still be faster algorithms – I'm just trying to optimize the implementation of your algorithm).

 public static int[] findTwoSum(int[] numbers, int target) {
 int[] numbersSorted = Arrays.copyOf(numbers, numbers.length);
 Arrays.sort(numbersSorted);
 
 for (int i = 0; i < numbersSorted.length && numbersSorted[i] <= target / 2; i++) {
 int j = Arrays.binarySearch(
 numbersSorted,
 i+1,
 numbersSorted.length,
 target - numbersSorted[i]);
 
 if (j >= 0) {
 return new int[]{i, j};
 }
 }
 return null;
 }

 public static int[] findTwoSum(int[] numbers, int target) {
 int[] numbersSorted = Arrays.copyOf(numbers, numbers.length);
 Arrays.sort(numbersSorted);
 List<Integer> numberPair = new ArrayList<>();

 for (int i = 0; i < numbersSorted.length && numbersSorted[i] <= target / 2; i++) {
 int j = Arrays.binarySearch(
 numbersSorted,
 i + 1,
 numbersSorted.length,
 target - numbersSorted[i]);
 if (j >= 0) {
 numberPair.add(numbersSorted[i]);
  numberPair.add(numbersSorted[j]);
  break;
 }
 }
 /* The numbers themselves are found, now get their
 indices in the original array */

 if (numberPair.isEmpty()) {
  return null;
 } else {
 assert numberPair.size() == 2;
 List<Integer> originalIndexes = new ArrayList<>();
 for (int i = 0; i < numbers.length && originalIndexes.size() < 2; i++) {
 if (numberPair.contains(numbers[i])) {
 originalIndexes.add(i);
  numberPair.remove(Integer.valueOf(numbers[i]));
 /* ^
 explicit boxing necessary, otherwise
  List.remove(int) will be called
 */
 }
 }
 assert originalIndexes.size() == 2;
 assert numberPair.isEmpty();
 return new int[]{originalIndexes.get(0), originalIndexes.get(1)};
 }
 }