Сортировать массив двухмерных строк на основе другого массива строк - Java

Question

Как гласит заголовок, я хочу реализовать метод, который позволил бы мне сортировать 2d массив по столбцу на основе массива, например сортировать 2d массив по столбцу 2 на основе порядка массива.

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.Если строки секунд совпадают, сравнивается первая строка, а затем третья строка.Следите за тем, чтобы он проверял наличие нулевых строк.

Важная часть:

 @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]

НТН!

Answer 2

Предполагая, что кошка, собака и обезьяна являются объектами String:

  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

Вам нужен Comparator<String[]>, который зависит от a2 массива:

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