基于另一个字符串数组对二维字符串数组进行排序 - Java

Question

正如标题所述，我希望实现一种方法，该方法允许我对给定基于数组的列的二维数组进行排序，例如根据数组的顺序，按第 2 列对 2d 数组进行排序。

String[][] a1 = new String[][]{
  {x,dog,x}
  {x,monkey,x}
  {x,cat,x}
}
//x being a random string

String[] a2 = new String[]{dog,cat,monkey};

//Output should be:
 a1 = {
  {x,dog,x}
  {x,cat,x}
  {x,monkey,x}
 }

我不确定从这一点开始往哪个方向发展，我已经查看了比较器，但我不确定在这种情况下我将如何实现它。感谢任何帮助我完成此任务的指导。

Answer 1

您需要一个依赖于a2 数组的Comparator<String[]>：

String[] a2 = new String[]{"dog", "cat", "monkey"};

Comparator<String[]> comparator = (arr1, arr2) -> {
    List<String> list = Arrays.asList(a2);

    int index1 = list.indexOf(arr1[1]);
    int index2 = list.indexOf(arr2[1]);

    return Integer.compare(index1, index2);
};

Arrays.sort(a1, comparator);
System.out.println(Arrays.deepToString(a1));

Answer 2

假设猫、狗和猴子为字符串对象：

  Arrays.stream(a1).sorted(Comparator.comparingInt(s -> -1 * Arrays.asList(a2).indexOf(s[1]))).toArray(String[][]::new);

Answer 3

扩展@Ruslan 的答案，Comparator 是正确的方法，但您可能不想为排序中的每个比较都做一个 indexof，所以您希望首先将参考字符串映射到反向索引：

    String[] a2 = new String[]{"dog", "cat", "monkey"};
    Map<String, Integer> order = new HashMap<>();
    for(int i = 0; i < a2.length; i++) {
      order.put(a2[i], i);
    }

    Comparator<String[]> comparator = (arr1, arr2) -> {
      int index1 = order.get(arr1[1]);
      int index2 = order.get(arr2[1]);

      return Integer.compare(index1, index2);
    };

    Arrays.sort(a1, comparator);

Answer 4

这里有一个可以帮助你的 sn-p。 它按照 a2 提供的顺序根据字符串编号 2 对数组进行排序。如果秒字符串相同，它会先比较第一个字符串，然后再比较第三个字符串。 注意它确实会检查空字符串。

重要的是：

 @Override
    public int compare(String[] o1, String[] o2) {      
        int score1 = types.indexOf(o1[1])-types.indexOf(o2[1]);
        if(score1!=0) {
            return score1;
        }

        int score2 = o1[0].compareTo(o2[0]);
        if(score2!=0) {
            return score2;
        }

        int score3 = o1[2].compareTo(o2[2]);
        return score3;
    }

见：

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Stream;

public class SpecialComparatorMain implements Comparator<String[]> {

    private List<String> types;

    public SpecialComparatorMain(List<String> types) {
        this.types = types;
    }

    public static void main(String[] args) {
        String[] a2 = new String[]{"dog","cat","monkey"};
        String[][] a1 = new String[][]{
              {"z","dog","x"},
              {"y","monkey","x"},
              {"x","cat","x"},
              {"x","monkey","x"},
              {"y","cat","x"},
              {"z","monkey","z"},
              {"z","monkey","y"},
              {"z","monkey","x"},
            };
            //x being a random string

            System.out.println("Before");
            Stream.of(a1).map(Arrays::toString).forEach(System.out::println);

            Arrays.sort(a1, new SpecialComparatorMain(Arrays.asList(a2)));

            System.out.println("After");
            Stream.of(a1).map(Arrays::toString).forEach(System.out::println);

    }

    @Override
    public int compare(String[] o1, String[] o2) {      
        int score1 = types.indexOf(o1[1])-types.indexOf(o2[1]);
        if(score1!=0) {
            return score1;
        }

        int score2 = o1[0].compareTo(o2[0]);
        if(score2!=0) {
            return score2;
        }

        int score3 = o1[2].compareTo(o2[2]);
        return score3;
    }

}

输出：

Before
[z, dog, x]
[y, monkey, x]
[x, cat, x]
[x, monkey, x]
[y, cat, x]
[z, monkey, z]
[z, monkey, y]
[z, monkey, x]

After
[z, dog, x]
[x, cat, x]
[y, cat, x]
[x, monkey, x]
[y, monkey, x]
[z, monkey, x]
[z, monkey, y]
[z, monkey, z]

HTH！