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

Question

I have 2 arrays in java

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

if I sort the int array in ascending order,it'll be :

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

now I want to sort the name array accordingly. The output should be :

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

how can I maintain a relation? I've seen this link( Sort Array based on other Sorted Array ),but its for js

Answer 1

You can create a custom class with the combined data, ie one integer variable and one string variable. This class would implement the Comparable interface and override its compareTo() method. Then create an array of objects of this class, and sort it using normal Arrays.sort() function of util library.

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

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

Usage:

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

Answer 2

Using Java 8 Streams API

You can build a stream of all valid indexes, sort that stream according to the num array and then map the indexes to the name values and collect them in a new array.

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]);

And if needed (due to name array passed as reference to be "sorted" in-place), just copy the sorted values to the original array:

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

Note that this way the array num is left untouched.

---

Using a custom implementation of Bubble Sort

As already figured out by the asker and mentioned by Jayanand the task is also easily accomplished by swapping elements in both array simultaneously whenever the sorting algorithm instructs to do so.

An implementation that uses both arrays directly:

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;
        }
    }
}

If you want to keep the logic and the value access separated so that Bubble Sort can be used for virtually any flavour indexed data structure:

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;
        });

As the average complexity of Bubble Sort is O(n²) (see its description at Wikipedia ) it doesn't make much sense to rant about unnecessary integer boxing and unboxing here.

---

Using data objects

Create a new class for objects keeping both num and name value:

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

Now if you have eg a List<Item> items it can be easily sorted using:

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

To create such a list from your arrays you could use (similarly to using Streams API for sorting):

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

---

Summary

What could be considered the best solution heavily depends on the particular use case that you have.

If you have no choice but working with those two arrays because they are passed to you in the context of some API or project where you are unable to change the design Bubble Sort with customized comparison and swap operations is definitely to be considered as long as you don't have thounsands of values to be sorted in which case it will be extremely slow.

If you have the freedom to decide how the num/name-pairs can be modeled I strongly suggest to design a specific class for those as already pointed out by iavanish . Be sure to implement equals and hashCode accordingly and keep in mind that when also implementing the Comparable interface it should reflect the natural order which should be in sync with the equals method. So when calling equals for two objects (5, a) and (5, b) and the result is false the compareTo method should not return 0. If you need a particular order that is not natural go for Comparator instead.

Sorting using the Streams API is to be prefered when working with a large number of values so that the initialization and integer boxing/unboxing overhead can be disregarded. In that case also .parallel() could additionally be used in order to gain even more speed.

Answer 3

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

  // During sorting int array...
  //Use indexes to switch the characters as well from     string array
  //Eg. If 2 from int array is shifting at index 0 from index 1 
 //Then also shift String[1] to String [0]

Answer 4

Sorry,it was easy :

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;
                }
            }
        }