Question

假设用户输入一个数组，例如：

Array = {France, Spain, France, France, Italy, Spain, Spain, Italy}

我确实知道它的长度

index数组将是：

index = {0, 1, 2, 3, 4, 5, 6, 7}

现在，使用Arrays.sort(Array);

对其进行排序后

newArray就像：

newArray = {France, France, France, Italy, Italy, Spain, Spain, Spain}

而newIndex将是：

newIndex = {0, 2, 3, 4, 7, 1, 5, 6}

问题是：如何从输入数组中找到newIndex？

提前致谢

Answer 1

不要对数组进行排序。对索引数组进行排序，传入一个比较器，该比较器使用作为索引将值与数组进行比较。所以你最终会得到newIndex作为排序的结果，从那里到实际项目的排序数组是微不足道的。

不可否认，这意味着以自定义方式排序整数数组 - 这意味着使用Integer[]和标准Java库，或者具有“IntComparator”接口的第三方库可以结合使用使用sort(int[], IntComparator)类型的方法。

编辑：好的，这是一个比较示例。为了简单起见，我假设你只想对一个“原始”字符串数组进行排序......我不会为无效测试而烦恼。

public class ArrayIndexComparator implements Comparator<Integer>
{
    private final String[] array;

    public ArrayIndexComparator(String[] array)
    {
        this.array = array;
    }

    public Integer[] createIndexArray()
    {
        Integer[] indexes = new Integer[array.length];
        for (int i = 0; i < array.length; i++)
        {
            indexes[i] = i; // Autoboxing
        }
        return indexes;
    }

    @Override
    public int compare(Integer index1, Integer index2)
    {
         // Autounbox from Integer to int to use as array indexes
        return array[index1].compareTo(array[index2]);
    }
}

你会这样使用它：

String[] countries = { "France", "Spain", ... };
ArrayIndexComparator comparator = new ArrayIndexComparator(countries);
Integer[] indexes = comparator.createIndexArray();
Arrays.sort(indexes, comparator);
// Now the indexes are in appropriate order.

Answer 2

使用Java 8 Stream API实现此目的的简明方法

final String[] strArr = {"France", "Spain", "France"};
int[] sortedIndices = IntStream.range(0, strArr.length)
                .boxed().sorted((i, j) -> strArr[i].compareTo(strArr[j]) )
                .mapToInt(ele -> ele).toArray();

Answer 3

TreeMap<String,Int> map = new TreeMap<String,Int>();
for( int i : indexes ) {
    map.put( stringarray[i], i );
}

现在迭代map.values（）以按排序顺序检索索引，并通过map.keySet（）获取字符串，或通过map.entrySet（）获取String-index-Pairs。

Answer 4

我根据@Skeet的代码制作了以下内容。我认为这是一个更多的OOPie。我不知道。

public static <T extends Comparable<T>> List<Integer> sortIndex(List<T> in) {
    ArrayList<Integer> index = new ArrayList<>();
    for (int i = 0; i < in.size(); i++) {
        index.add(i);
    }

    Collections.sort(index, new Comparator<Integer>() {
        @Override
        public int compare(Integer idx1, Integer idx2) {
            return in.get(idx1).compareTo(in.get(idx2));
        }
    });

    return index;
}

原始数组中的对象必须实现Comparable接口，而不是实现具有用于进入的不同对象的Comparator代码的排序和索引的类。似乎许多感兴趣的对象具有自然的顺序，并且已经实现了Comparable接口。

public static void main(String[] args) {

    List<Integer> a1 = new ArrayList<>(Arrays.asList(2, 3, 9, 4, 1));
    // Just pass in the list to have its indexes sorted by the natural ordering
    List<Integer> idx = sortIndex(a1);

    List<Double> a2 = new ArrayList<>(Arrays.asList(1.0, 5.3, 5.2, -3.1, 0.3));
    idx = sortIndex(a2);

    List<numBits> a3 = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        a3.add(new numBits(i));
    }

    // If you need to sort the indexes of your own object, you must implement
    // the Comparable Interface.
    idx = sortIndex(a3);
}

static class numBits implements Comparable<numBits> {
    private int a;

    public numBits(int i) {
        a = i;
    }

    public String toString() {
        return Integer.toString(a);
    }

    // Sort by the total number of bits in the number.
    @Override
    public int compareTo(numBits that) {
        if (Integer.bitCount(this.a) < Integer.bitCount(that.a))
            return -1;
        if (Integer.bitCount(this.a) > Integer.bitCount(that.a))
            return 1;
        return 0;
    }
}

Answer 5

如果有一个重复排序具有正值的原始浮点数或int数组的场景，那么与使用任何比较器相比，下面的方法产生更好的（x3~x4）速度：

long time = System.currentTimeMillis();
for (int i = 0; i < iters; i++) {           
    float[] array = RandomUtils.randomFloatArray(-1,  1, 3000);
    long[] valueKeyPairs = new long[array.length]; 
    for (int j = 0; j < array.length; ++j) {
        valueKeyPairs[j] = (((long) Float.floatToIntBits(array[j])) << 32) | (j & 0xffffffffL);
    }
    Arrays.sort(valueKeyPairs);
    /**Then use this to retrieve the original value and index*/
    //long l = valueKeyPairs[j];
    //float value = Float.intBitsToFloat((int) (l >> 32));
    //int index = (int) (l);
}
long millis = System.currentTimeMillis() - time;

Answer 6

您可以这样做的一种方法是将原始索引和国家/地区名称包装到单独的类中。然后根据名称对Array进行排序。这样，您的原始索引将被保留。

Answer 7

第一眼看到的是将它们映射到那个

Map <Integer, String> map = new HashMap<Integer, String>();
map.put(0, "France");
map.put(1, "Spain");
map.put(2, "France");

然后按值like that对它们进行排序，然后您就可以知道它们的索引和值（键，值）只是打印地图

Iterator mapIterator = map.keySet().iterator();  

while (mapIterator .hasNext()) {  
     String key = mapIterator.next().toString();  
     String value = map.get(key).toString();  

     System.out.println(key + " " + value);  
}

Answer 8

我找到了解决方案。

List<String> a = {b, a, d, c};
List<Integer> b = {2, 1, 4, 3};

如果 a 排序

private void setsortb() {
List<String> beforeA = new ArrayList<>();
List<Integer> beforeB = new ArrayList<>();
beforeA.addAll(a);
beforeB.addAll(b);
a.sort();//change like this {a, b, c, d}

for(int i = 0; i < beforeA.size(); i++) {
int index = beforeA.indexOf(a.get(i));
b.set(i, beforeB.get(i));
}
}

喜欢这个

结果

a = {a, b, c, d}
b = {1, 2, 3, 4}

排序后获取数组的索引？

8 个答案: