thenComparingによってlong[] の 第一要素、第二要素の順でソートしたい

Question

thenComparingを用いて長さ2の配列の集合を第一要素、第二要素の優先度順でソートしたいと考えています。
具体的には

Arrays.sort(a, new Comparator<int[]>() {
	@Override
	public int compare(long[] o1, long[] o2) {
		if(o1[0]!=o2[0]) return Long.compare(o1[0], o2[0]);
		else return Long.compare(o1[1], o2[1]);
	}
});

と同じ働きをするコードを書きたいです。
第一要素によるソートは

Arrays.sort(a, Comparator.comparing(v->v[0]));

とすることで行うことが出来ることを手元で確かめています。

しかし、第二要素による比較を入れた

Arrays.sort(a, Comparator.comparing(v->v[0]).thenComparing(v->v[1]));

ですと、Exception in thread "main" java.lang.Error: Unresolved compilation problem:
というエラーが発生してしまいます。修正方法の分かる方ご教示ください。

Answer 1

とりあえず。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Sorters {

  static Comparator<long[]> comparator1 = Comparator.comparing(v -> v[0] * Integer.MAX_VALUE + v[1]);
  static Comparator<long[]> comparator2 = Comparator.comparing((long[] v) -> v[0]).thenComparing(v -> v[1]);
  static Comparator<long[]> comparator3 = Comparator.<long[], Long>comparing(v -> v[0]).thenComparing(v -> v[1]);
  static Comparator<long[]> comparator4 = Comparator.<long[], Long>comparing(v -> v[0]).thenComparingLong(v -> v[1]);

  static Function<Integer,Function<long[],Long>> getElement = i -> (array) -> array[i];
  static Comparator<long[]> comparator13 = Comparator.comparing(getElement.apply(0)).thenComparing(getElement.apply(1));

  static Comparator<long[]> comparator12 = (x,y) ->
    IntStream.range(0, Math.min(x.length,y.length))
             .map(i -> Long.compare(x[i], y[i]))
             .dropWhile(i -> i == 0)
             .findFirst()
             .orElse(0);

 static Function<Integer,Comparator<long[]>> genComparatorChain = size ->        
   IntStream.range(0,size)
            .mapToObj(i -> Comparator.<long[],Long>comparing(x -> x[i]))
            .reduce((a,b) -> 0, Comparator::thenComparing);
 static Comparator<long[]> comparator14 = genComparatorChain.apply(2);

  static BiFunction<Comparator<long[]>, long[][], long[][]> sorter = 
    (comparator, array) -> Arrays.stream(array)
                                 .sorted(comparator)
                                 .collect(Collectors.toList())
                                 .toArray(new long[0][0]);

  static Consumer<long[][]> dump_ = 
    array -> {
      Arrays.stream(array).map(Arrays::toString).forEach(System.out::println);
      System.out.println();
    };

  public static void main(String[] args) {
    long[][] a = { { 1, 3 }, { 2, 3 }, { 1, 2 }, { 9, 1 }, { 0, 9 }, { 0, 4 }};
    
    dump_.accept(sorter.apply(comparator1,a));
    dump_.accept(sorter.apply(comparator2,a));
    dump_.accept(sorter.apply(comparator3,a));
    dump_.accept(sorter.apply(comparator4,a)); 
    dump_.accept(sorter.apply(comparator13,a));
    dump_.accept(sorter.apply(comparator12,a));  
    dump_.accept(sorter.apply(comparator14,a));  
  }
}

結論(追記)

thenComparingのkyExtractorの型が推論されない問題の解決として、以下の３つの方法がありました。

• Comparator.comparingに指定するラムダ式の、引数に型long[]を指定する
• staticメソッドComparator.comparingにkeyExtractorの型<long[], Long>を指定する
• あらかじめkeyExtractor関数Function<long[],Long>を定義しておき渡す。

// 1
Comparator.comparing((long[] v) -> v[0]).thenComparing(v -> v[1]);
// 2
Comparator.<long[], Long>comparing(v -> v[0]).thenComparing(v -> v[1]);
// 3
Function<Integer,Function<long[],Long>> getElement = i -> (array) -> array[i];
Comparator<long[]> comparator13 = Comparator.comparing(getElement.apply(0)).thenComparing(getElement.apply(1));

配列のサイズに合わせたComparator<long[]>(追記)

結論の３番目を変形して、配列のサイズに応じたComparator<long[]>が作れることがわかりました。

Function<Integer,Comparator<long[]>> genComparatorChain = size ->        
  IntStream.range(0,size)
           .mapToObj(i -> Comparator.<long[],Long>comparing(x -> x[i]))
           .reduce((a,b) -> 0, Comparator::thenComparing);
Comparator<long[]> comparator14 = genComparatorChain.apply(2);

結論：Comparatorに限らず、Functionインターフェイスでもreduce()を使って、compose()、andThen()をチェインできることがわかり有益でした。

Comments

[xebme]

結論を追記しました。
最後に、配列のサイズに合わせたComparator<long[]>を追記しました。
有益な質問でした。ありがとうございます。

[swordone]

個人的にラッパークラスを使っているのが嫌なので、ラッパークラスを避けて書いてみました。
IntFunction<Comparator<long[]>> genComparatorChain = size ->
IntStream.range(0,size).mapToObj(i -> Comparator.comparingLong((long[] x) -> x[i])
.reduce((a, b) -> 0, Comparator::thenComparing);

[xebme]

ありがとうございます。Comparatorの動作が1回多くなるのが課題です。

Answer 2

v の型を明示したらいけましたけど、負けた気がする…。

import java.util.*;

public class Sorter {
  public static void main(String[] args) {
    int[][] a = {
      {1, 3}, {2, 3}, {1, 2}
    };

    //Arrays.sort(a, Comparator.comparing(v->v[0]));
    //Arrays.sort(a, Comparator.comparing(v -> v[0]).thenComparing(v -> v[1]));
    Arrays.sort(a, Comparator.comparing((int[] v) -> v[0]).thenComparing(v -> v[1]));

    for (int[] b : a) {
      System.out.println("{" + b[0] + ", " + b[1] + "}");
    }
  }
}

Comments

[swordone]

でも実際それしかないんですよね。

あと型間違えています。