数组排序并返回原索引值

import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.stream.Collectors;

public class ArrayUtil {
	/**
	 * 排序后返回索引
	 * @param v
	 * @param <T>
	 * @return
	 */
	public static <T> int[] sortToIndex(T[] v) {
	    Map<T, Queue<Integer>> indexMap = new HashMap<>();
	    for (int i=0; i<v.length; i++) {
	        Queue<Integer> indexes = indexMap.get(v[i]);
	        if (indexes == null)
	            indexes = new ArrayDeque<>();
	        indexes.add(i);
	        indexMap.put(v[i], indexes);
	    }
	    List<T> vSorted = Arrays.stream(v).sorted().collect(Collectors.toList());
	    int[] indexes = new int[vSorted.size()];
	    for (int i=0; i<vSorted.size(); i++) {
	        Queue<Integer> itemIndexes = indexMap.get(vSorted.get(i));
	        Integer index = itemIndexes.poll();
	        if (index == null)
	            throw new RuntimeException("itemIndexes为空");
	        indexes[i] = index;
	    }
	    return indexes;
	}

	
	public static int[] quickSort(int[] keys) {
        int[] indices = new int[keys.length];
        for (int i = 0; i < keys.length; i++) {
            indices[i] = i;
        }
        quickSort(keys, 0, keys.length-1, indices);
        return indices;
    }
	
	private static void quickSort(int[] keys, int begin, int end, int[] indices) {
        if (begin >= 0 && begin < keys.length && end >= 0 && end < keys.length && begin < end) {
            int i = begin, j = end;
            int vot = keys[i];
            int temp = indices[i];
            while (i != j) {
                while(i < j && keys[j] >= vot) j--;
                if(i < j) {
                    keys[i] = keys[j];
                    indices[i] = indices[j];
                    i++;
                }
                while(i < j && keys[i] <= vot)  i++;
                if(i < j) {
                    keys[j] = keys[i];
                    indices[j] = indices[i];
                    j--;
                }
            }
            keys[i] = vot;
            indices[i] = temp;
            quickSort(keys, begin, j-1, indices);
            quickSort(keys, i+1, end, indices);
        }
    }
	
	public static void main(String[] args) {
		int[] arr = {10,7,2,4,3,8,9,19};
        System.out.println("----排序前----");
        System.out.println(Arrays.toString(arr));
        int[] index = quickSort(arr);
        System.out.println("----排序后----");
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(index));
        System.out.println("------------");
        
		String[] arr1 = {"10","3","7","2"};
		int[] a = sortToIndex(arr1);
		
		System.out.println(Arrays.toString(a));
	}
	

}

----排序前----
[10, 7, 2, 4, 3, 8, 9, 19]
----排序后----
[2, 3, 4, 7, 8, 9, 10, 19]
[2, 4, 3, 1, 5, 6, 0, 7]

---

[0, 3, 1, 2]