【Java】CollectorsクラスのgroupingByメソッドを使用した際の出力順序について

Question

いつもお世話になっております。

CollectorsクラスのgroupingByメソッドの仕様について、質問をさせていただきたいです。

上記のメソッドを使用した際に、グルーピングが行われますが、その結果を出力した際の出力順序には、決まりはないのでしょうか。

groupByの対象となるListの中身

• new Musician("Jimi Hendrix", Musician.Category.ROCK)
• new Musician("Eric Dolphy", Musician.Category.JAZZ)
• new Musician("J.S.Bach", Musician.Category.CLASSICAL)
• new Musician("Charles Mingus", Musician.Category.JAZZ)

Collectorsクラス：groupingBy Javadoc

リストの中身の順番を変えた場合の出力結果をいくつか記載致します。

<出力結果>
{JAZZ=[Eric Dolphy, Charles Mingus], ROCK=[Jimi Hendrix], CLASSICAL=[J.S.Bach]}

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {

	public static void main(String[] args) {

		List<Musician> musicList = Arrays.asList(
　　　　　　　　new Musician("Jimi Hendrix", Musician.Category.ROCK),
				new Musician("Eric Dolphy", Musician.Category.JAZZ),
				new Musician("J.S.Bach", Musician.Category.CLASSICAL),
				new Musician("Charles Mingus", Musician.Category.JAZZ));


		Map<Musician.Category, List<String>> map = musicList.stream().collect(Collectors
				.groupingBy(Musician::getCategory, Collectors.mapping(Musician::getName, Collectors.toList())));
		
		System.out.println(map);
	}

}

public class Musician {
	public enum Category {
		ROCK, JAZZ, CLASSICAL
	}

	private String name;
	private Category category;

	public Musician(String name, Category category) {
		this.name = name;
		this.category = category;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Category getCategory() {
		return category;
	}

	public void setCategory(Category category) {
		this.category = category;
	}

}

<出力結果>
{CLASSICAL=[J.S.Bach], JAZZ=[Eric Dolphy, Charles Mingus], ROCK=[Jimi Hendrix]}

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {

	public static void main(String[] args) {

		List<Musician> musicList = Arrays.asList(
                new Musician("Eric Dolphy", Musician.Category.JAZZ),
				new Musician("J.S.Bach", Musician.Category.CLASSICAL),
				new Musician("Charles Mingus", Musician.Category.JAZZ),
				new Musician("Jimi Hendrix", Musician.Category.ROCK));

		Map<Musician.Category, List<String>> map = musicList.stream().collect(Collectors
				.groupingBy(Musician::getCategory, Collectors.mapping(Musician::getName, Collectors.toList())));

		System.out.println(map);
	}

}

<出力結果>
{JAZZ=[Charles Mingus, Eric Dolphy], CLASSICAL=[J.S.Bach], ROCK=[Jimi Hendrix]}

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {

	public static void main(String[] args) {

		List<Musician> musicList = Arrays.asList(
				new Musician("J.S.Bach", Musician.Category.CLASSICAL),
				new Musician("Charles Mingus", Musician.Category.JAZZ),
				new Musician("Jimi Hendrix", Musician.Category.ROCK),
        　　　　 new Musician("Eric Dolphy", Musician.Category.JAZZ));

		Map<Musician.Category, List<String>> map = musicList.stream().collect(Collectors
				.groupingBy(Musician::getCategory, Collectors.mapping(Musician::getName, Collectors.toList())));

		System.out.println(map);
	}

}

Answer 1

Mapのキーの並びが気に入らないのであれば、キーでソートしてくれるインスタンスを渡せばよろしいのではないかと。

swordoneさんの指摘を反映しました。

Mapのキーの並びが気に入らないのであれば、キーの自然順序(enum定数の宣言される順序)に並べてくれるインスタンスを渡せばよろしいのではないかと。

• EnumMap

            Map<Musician.Category, List<String>> map =
                    musicList.stream().collect(
                            Collectors.groupingBy(
                                    Musician::getCategory,
                                    // EnumMap::new,  <- こうは、書けないので訂正します
                                    () -> new EnumMap<>(Musician.Category.class),
                                    Collectors.mapping(Musician::getName, Collectors.toList())));

---

xebmeさんからのお題。

2020/04/25 00:47
グループ分けされた音楽家名もCollectors#toCollectionで並べかえてください

わたしには、荷が重すぎました。Collectors#toCollection()の例。是非ご提示いただければ。 > xebmeさん

    for (int count = 0; count < 3; count++) {
      Collections.shuffle(musicList);
      final Map<Musician.Category, List<String>> map = musicList.stream().collect(Collectors
          .groupingBy(Musician::getCategory,
              () -> new EnumMap<>(Musician.Category.class),
              Collectors.mapping(Musician::getName, Collectors.toCollection(() -> new ArrayList<>()))))
          .entrySet().stream()
          .collect(
              Collectors.toMap(
                  x -> x.getKey(),
                  k -> {
                    Collections.sort(k.getValue());
                    return k.getValue();
                  },
                  (a, b) -> {
                    System.out.println("   a: " + a);
                    System.out.println("   b: " + b);
                    a.addAll(b);
                    Collections.sort(a);
                    return a;
                  },
                  () -> new EnumMap<>(Musician.Category.class)));

      System.out.println(String.format("(%s) (%s) : %s", count, map.getClass().getSimpleName(), map));
    }

こっちだと、みじかく書けるのですが (^^;

    repeat(3) { count ->
      val map =
          musicList.shuffled()
              .groupBy { it.category }
              .map { entry -> entry.key to entry.value.map { it.name }.sorted() }
              .toMap(EnumMap(Musician.Category::class.java))
      println("(%s) (%s) : %s".format(count, map.javaClass.simpleName, map))
    }

Comments

[swordone]

Enumがキーなので、EnumMapのほうが適しているかと思います。

[shiketa]

EnumMapの存在は気づいていませんでした。指摘ありがとうございました。ひとつ道具が増えました。

[xebme]

グループ分けされた音楽家名もCollectors#toCollectionで並べかえてください。

[shiketa]

やはりそう来ますよね。わたしには、荷が重すぎました。Collectors#toCollection()の例。是非ご提示いただければ m(._.)m

Answer 2

JavaDocに書いてあるように、

返されるMapの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。

Java標準で用意してあるMapでも、実装の中に順序が保証されないものがあるわけですし、「順番についても何も保証されない」と考えるのがいちばん安全です。

Comments

[kazu0630]

皆様、ご回答いただき、ありがとうございました。

いろいろとコメントのやり取りを拝見し、勉強させていただきました。
また、機会がありましたら、ご回答いただけますと幸いです。

この度はありがとうございました。

Answer 3

CollectorsクラスのgroupingByメソッドの仕様について、質問をさせていただきたいです。
上記のメソッドを使用した際に、グルーピングが行われますが、その結果を出力した際の出力順序には、決まりはないのでしょうか。

# はなしがずれてきてしまった感があるので、ここに対して。

件のメソッドの実装はこう。

public final class Collectors {
    ...
    public static <T, K, A, D>
    Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
    }

返さえるMapの実装は、HashMap。

• https://docs.oracle.com/javase/jp/8/docs/api/java/util/HashMap.html

曰く。

Mapインタフェースのハッシュ表に基づく実装です。...このクラスはマップの順序を保証しません。特に、その順序を常に一定に保つことを保証しません。

「順序を保証し」ないそうです。さらに「順序を常に一定に保つことを保証しません」との由。

Comments

[xebme]

質問の意図は何か。
・デフォルト実装を使うなら順序を保証しない。
・自分でSupplierを指定するなら順序性を持たせることができる。
ということですね。前者を意図するのであれば後者は答える必要がない。

[shiketa]

わたしが TreeMap::new を持ち出したので、はなしがずれてしまった... (^^;

Answer 4

コレクションの並び順

コレクションの要素の並び順を決定するのはComparatorです。この問題は、格納するコレクションを生成する際、どの並び順のComparatorを指定するかを考えることです。

Map<Musician.Category, Set<String>>

並び順を管理しやすいように、カテゴリ用のMapに順序を指定できるTreeMapを、音楽家用のSetに重複を排除し順序を指定できるTreeSetを使用します。Collectors.groupnigByに指定するSupplierをそれぞれ以下のように定義。

カテゴリ別、音楽家のリスト、カテゴリの整列順

// カテゴリ別マップのSupplier
() -> new TreeMap<>(カテゴリ用のComparator)

// カテゴリ名順
Comparator.<Musician.Category, String>comparing(c -> c.name());
// カテゴリの定義順
Comparator.<Musician.Category, Integer>comparing(c -> c.ordinal());
// カテゴリの自然順(定義順)
Comparator.<Musician.Category>naturalOrder();
// カテゴリの自然逆順(定義逆順)
Comparator.<Musician.Category>reverseOrder();

音楽家のセット（重複排除）の整列順

// 音楽家セットのSupplier
() -> new TreeSet<>(音楽家用のComparator)

// 音楽家の自然順
Comparator.<String>naturalOrder();
// 音楽家の自然逆順
Comparator.<String>reverseOrder();

Collectors.groupnigByにSupplierの設定

カテゴリ用のComparator、音楽家用のComparator、をそれぞれ適用します。

musicianList -> 
  musicianList.stream()
    .collect(
      Collectors.groupingBy(
      Musician::getCategory,
      () -> new TreeMap<>(カテゴリ用のComparator),
        Collectors.mapping(
          Musician::getName, 
          Collectors.toCollection(() -> new TreeSet<>(音楽家用のComparator)))));

テスト用コード

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

public class MusicianTest_ {

  static Comparator<Musician.Category> categoryNameOrder = Comparator.<Musician.Category, String>comparing(c -> c.name());
  static Comparator<Musician.Category> categoryOrder = Comparator.<Musician.Category, Integer>comparing(c -> c.ordinal());
  static Comparator<Musician.Category> categoryNaturalOrder = Comparator.<Musician.Category>naturalOrder();
  static Comparator<Musician.Category> categoryReverseOrder = Comparator.<Musician.Category>reverseOrder();

  static Comparator<String> musicianNaturalOrder = Comparator.naturalOrder();
  static Comparator<String> musicianReverseOrder = Comparator.reverseOrder();

  static BiFunction<Comparator<Musician.Category>, Comparator<String>, Function<List<Musician>, Map<Musician.Category, Set<String>>>> supplyFunc = 
   (categoryComparator, musicianComparator) -> 
    musicianList -> 
      musicianList.stream()
                  .collect(
                    Collectors.groupingBy(
                      Musician::getCategory,
                      () -> new TreeMap<>(categoryComparator),
                      Collectors.mapping(
                        Musician::getName, 
                        Collectors.toCollection(() -> new TreeSet<>(musicianComparator)))));

  public static void main(String[] args) {

    List<Musician> musicianList = Arrays.asList(
      new Musician("Jimi Hendrix", Musician.Category.ROCK),
      new Musician("Jeff Beck", Musician.Category.ROCK),
      new Musician("Eric Dolphy", Musician.Category.JAZZ), 
      new Musician("Johann Sebastian Bach", Musician.Category.CLASSICAL),
      new Musician("Josquin Des Prez", Musician.Category.CLASSICAL),
      new Musician("François Couperin", Musician.Category.CLASSICAL),
      new Musician("Charles Mingus", Musician.Category.JAZZ),
      new Musician("Art Tatum", Musician.Category.JAZZ));

    Map<Musician.Category, Set<String>> map = null;
    System.out.print("カテゴリ名順、音楽家名昇順 : ");
    map = (supplyFunc.apply(categoryNameOrder, musicianNaturalOrder)).apply(musicianList);
    System.out.println(map);
    System.out.print("カテゴリ名順、音楽家名降順 : ");
    map = (supplyFunc.apply(categoryNameOrder, musicianReverseOrder)).apply(musicianList);
    System.out.println(map);
    System.out.print("カテゴリ順、音楽家名昇順 : ");
    map = (supplyFunc.apply(categoryOrder, musicianNaturalOrder)).apply(musicianList);
    System.out.println(map);
    System.out.print("カテゴリ順、音楽家名降順 : ");
    map = (supplyFunc.apply(categoryOrder, musicianReverseOrder)).apply(musicianList);
    System.out.println(map);

  }

}

Comments

[shiketa]

ありがとうございます。
nameの重複を勝手に排除してはいけないと判断していたので、TreeSetは避けていましたった。

[xebme]

質問の読み間違いでした。
groupingByのデフォルト実装の結果は総称的なMapである。したがって順序は保証されない。(当然)
(しかしサプライヤーを指定することで順序性を持つMapに格納することもできる)