java中基于其他数组的数组排序

Question

我有2个java数组

int[] num={5,2,10,12,4};
String[] name={"a","b","g","c","r"};

如果我按升序对int数组排序，它将是：

int[] num={2,4,5,10,12};

现在我想相应地对名称数组进行排序。输出应为：

String[] name={"b","r","a","g","c"};

我该如何维持一段关系？我见过这个链接(基于其他排序的数组排序数组)，但它是针对js的

Answer 1

您可以构建一个包含所有有效索引的流，根据< code>num数组对该流进行排序，然后将索引映射到< code>name值，并将它们收集到一个新数组中。

String[] nameSorted = IntStream.range(0, num.length).boxed()
        .sorted((i, j) -> Integer.compare(num[i], num[j]))
        .map(i -> name[i])
        .toArray(x -> new String[x]);

如果需要（由于＜code＞name＜/code＞数组作为引用传递，要就地“排序”），只需将排序后的值复制到原始数组：

System.arraycopy(nameSorted, 0, name, 0, name.length);

请注意，以这种方式，数组num保持不变。

正如提问者已经理解的和Jayanand提到的那样，只要排序算法发出指令，只要同时交换两个数组中的元素，任务也很容易完成。

直接使用这两个数组的实现：

for (int i = 0; i < num.length; i++) {
    for (int j = i + 1; j < num.length; j++) {
        if (num[i] > num[j]) {
            int tempNum = num[i];
            String tempName = name[i];
            num[i] = num[j];
            name[i] = name[j];
            num[j] = tempNum;
            name[j] = tempName;
        }
    }
}

如果要将逻辑和值访问分开，以便冒泡排序几乎可用于任何风格索引数据结构：

public static void bubbleSort(int length, IntBinaryOperator comparator,
        BiConsumer<Integer, Integer> swapOperation) {
    for (int i = 0; i < length; i++)
        for (int j = i + 1; j < length; j++)
            if (comparator.applyAsInt(i, j) > 0)
                swapOperation.accept(i, j);
}

bubbleSort(num.length, 
        (i, j) -> Integer.compare(num[i], num[j]), 
        (i, j) -> {
            int tempNum = num[i];
            String tempName = name[i];
            num[i] = num[j];
            name[i] = name[j];
            num[j] = tempNum;
            name[j] = tempName;
        });

由于气泡排序的平均复杂度为 O（n²）（请参阅维基百科上的描述），因此在这里抱怨不必要的整数装箱和拆箱没有多大意义。

为保留< code>num和< code>name值的对象创建一个新类:

class Item {
    int num;
    String name;
    Item(int num, String name) {
        this.num = num;
        this.name = name;
    }
}

现在，如果您有例如列表

items.sort(Comparator.comparing(item -> item.num));

要从数组中创建这样的列表，您可以使用(类似于使用Streams API进行排序):

List<Item> items = IntStream.range(0, num.length)
        .mapToObj(i -> new Item(num[i], name[i]))
        .collect(Collectors.toList());

什么可以被认为是最佳解决方案在很大程度上取决于您拥有的特定用例。

如果您别无选择，只能使用这两个数组，因为它们是在一些API或项目的上下文中传递给您的，而您无法更改设计气泡排序和定制的比较和交换操作，那么只要您没有成千上万的值要排序，这种情况下将会非常慢。

如果您可以自由决定如何对num/name-对建模，我强烈建议为那些已经由iavanish指出的类设计一个特定的类。一定要相应地实现< code>equals和< code>hashCode,并记住在实现< code>Comparable接口时，它应该反映自然顺序，该顺序应该与< code>equals方法同步。因此，当对两个对象(5，a)和(5，b)调用< code>equals并且结果为< code>false时，< code>compareTo方法不应返回0。如果您需要一个不自然的特殊顺序，请使用< code>Comparator。

在处理大量值时，应优先使用Streams API进行排序，以便可以忽略初始化和整数装箱/拆箱开销。在这种情况下，还可以额外使用。并行（）以获得更高的速度。

Answer 2

抱歉，这很简单:

int[] num={5,2,10,12,4};
String[] name={"a","b","g","c","r"};
int tempNum;
String tempName;

for (int i = 0; i < num.length; i++) 
        {
            for (int j = i + 1; j < num.length; j++) 
            {
                if (num[i] > num[j]) 
                {
                    tempNum = num[i];
                    tempName=name[i];

                    num[i] = num[j];
                    name[i] = name[j];

                    num[j] = tempNum;
                    name[j] = tempName;
                }
            }
        }

Answer 3

您可以使用组合数据创建自定义类，即一个整数变量和一个字符串变量。这个类将实现Comparable接口并覆盖它的compareTo()方法。然后创建这个类的对象数组，使用util库的normal Arrays.sort()函数进行排序。

public class Data implements Comparable<Data> {
    int num;
    String name;

    @Override
    public int compareTo(Data data) {
        return this.num - data.num;
    }
}

用法：

Data[] data = new Data[5];
// initialize data
Arrays.sort(data)
// now the num will be sorted in ascending order and name will be shuffled accordingly