如何对一个数组列表进行排序，并在java中设置另一个具有相同顺序的列表

Question

我有三个带有String的数组列表。我想对一个arraylist进行排序，并且使用相同的顺序想要在java中设置其他两个列表的元素。 我可以排序一个列表，但如何设置其他两个列表的元素与排序列表顺序。

谢谢并问候Rahul

Answer 1

到目前为止，最好的方法是重新考虑设计并将所有三个相关数据放入为此目的设计的类的实例中，然后只对一个ArrayList排序。

任何其他方法都会涉及设置一些Map来保存String之间的关系，然后在排序第一个之后手动移动列表（一个困难的混乱）或编写自己的排序算法，移动后两个列表与第一个串联（可能更容易，但更糟糕的是。）

Answer 2

private void sortingMechanism() {
for(int i=0;i<list1.size();i++){
    for(int j=i+1;j<list1.size();j++){
        if(list1.get(i)>list1.get(j)){
            Collections.swap(list1, i, j);
            Collections.swap(list2, i, j);
            Collections.swap(list3, i, j);

        }
    }
}
}

Answer 3

这是一种常见的需求。 一个选项（你可以使用Java的排序，这可能比你要写的更好）：

/**
 * Sorts by the first list 
 */
static void sort(List... lists) {
    assert lists.length > 0;

    Object[][] objects = new Object[lists[0].size()][lists.length];

    for (int i = 0; i < lists.length; i++) {
        int j = 0;
        for (Object object : lists[i]) {
            objects[j++][i] = object;
        }
    }

    Arrays.sort(objects, new Comparator<Object[]>() {
        public int compare(Object[] o1, Object[] o2) {
            return ((Comparable)o1[0]).compareTo(o2[0]);
        }
    });

    for (int i = 0; i < lists.length; i++) {
        lists[i].clear();
        for (Object[] tuple : objects) {
            lists[i].add(tuple[i]);
        }
    }
}

像它一样使用它

List<String> a = new ArrayList<String>(Arrays.asList(new String[]{"dog", "cat", "cat"}));
List<Integer> b = new LinkedList<Integer>(Arrays.asList(new Integer[]{1, 2, 3}));
List<Object> c = new Vector<Object>(Arrays.asList(new Object[]{"object", 0.5, new Object()}));

sort(a, b, c);

System.out.println(a);
System.out.println(b);
System.out.println(c);

使用它的一个缺点是它依赖于.clear（），这对于某些列表没有实现，但在这种情况下你可以调整它。

Answer 4

您还可以使用hashmap关联要排序的数组的值和另一个的值。 排序后，您可以使用第一个数组的值作为键轻松找到第二个数组的值。

Answer 5

一种方法是首先捕获排序顺序，然后将其应用于每个单独的数据列表。 下面是一个示例，它对两个数组进行排序，而不创建专门设计的对象来保存每个数组中的数据或实现自己的排序算法。 除了排序的要求之外，它的时间复杂度是O（N）并且需要两个额外的长度为N的整数数组.N是每个数据数组中的元素数量。

public static void main(String[] args) {
  //  Original data in multiple arrays
  String[] letters = new String[] {"C","D","B","E","A"};
  int[] numbers = new int[] {3,4,2,5,1};

  //  Array to hold the destination locations.
  //    Each element refers to the index of the element in the letters array
  //        that goes into that location.
  //    e.g.
  //    The case of [C, D, B, E, A], this array would contain [4, 2, 0, 1, 3].
  //    The 0-th element, 4, means that the 4th element in the source array (A)
  //    should end up in index 0.
  Integer[] srcIndexes = new Integer[letters.length];

  //  Assign indexes
  for (int i = 0; i < letters.length; ++i)
    srcIndexes[i] = i;

  //  Sort the destination index array according to the letters array.
  Arrays.sort(srcIndexes, (Integer a, Integer b) -> letters[a].compareTo(letters[b]));

  //  Array to hold the source locations.
  //    Each element refers to the index where the element in the letters array should go to.
  //    e.g.
  //    The case of [C, D, B, E, A], this array would contain [2, 3, 1, 4, 0].
  //    The 0-th element, 2, means that C should end up in index 2 of the resultant
  //    array (i.e. the destination index).
  int[] dstIndexes = new int[letters.length];
  for (int i = 0; i < letters.length; ++i) {
    dstIndexes[srcIndexes[i]] = i;
  }

  //  Iterate through the indexes to move the data in the data array into their resultant locations.
  for (int srcIndex = 0; srcIndex < letters.length; ) {
    int dstIndex = dstIndexes[srcIndex];

    //  Index is already in place.
    if (srcIndex==dstIndex) {
      ++srcIndex;
      continue;
    }

    //  Swap elements in the source and destination indexes.
    swap(dstIndexes, srcIndex, dstIndex); // Make sure to swap the indexes too.
    swap(letters, srcIndex, dstIndex);  // Swap elements in the letters array.
    swap(numbers, srcIndex, dstIndex);  // Swap elements in the numbers array.
  }

  System.out.println("Indexes : "+Arrays.toString(dstIndexes));
  System.out.println("Letters : "+Arrays.toString(letters));
  System.out.println("Numbers : "+Arrays.toString(numbers));
}

private static <T> void swap(T[] objArray, int i, int j) {
  T tmp = objArray[i];
  objArray[i] = objArray[j];
  objArray[j] = tmp;
}

private static void swap(int[] intArray, int i, int j) {
  int tmp = intArray[i];
  intArray[i] = intArray[j];
  intArray[j] = tmp;
}

Answer 6

如果您自己编写了排序代码，只需展开修改第一个数组的代码部分，以相同的方式修改其他两个数组。

虽然最佳方法是重构代码，使其中包含包含所有三个数组信息的对象的列表。

就像欧内斯特说:)

Answer 7

当您对第一个数组列表进行排序而不是仅交换第一个数组列表中的元素时，也可以使用相同的索引对另一个进行排序。

arraylist1[x]=arraylist1[y];
arraylist2[x]=arraylist2[y];
arraylist3[x]=arraylist3[y];

当然，在交换时还有其他步骤（比如分配给辅助变量），但这不是我想在这里展示的。