[JAVA] In Liste sortieren, für persönliches Memo

Umgebung

Java auf dieser Seite 1.8 Es ist zusammengebaut mit.

Was Sie versuchen zu tun

-Sortieren Sie die Klassen in der Liste in einer bestimmten Reihenfolge ・ Versuchen Sie es mit Stream ・ Verwenden Sie keinen Komparator

• Informationen zur Verwendung von Composer finden Sie in Schwertones Beitrag im Kommentarbereich unten auf der Seite!

Ich werde es sofort versuchen

Zuerst die Klasse in List

Hoge.java

private class Hoge {
	private final String priority;
	private final String name;

	private Hoge(String priority, String name) {
		this.priority = priority;
		this.name = name;
	}
}

So was. Es gibt keinen Getter / Setter, weil es problematisch ist.

Listengenerierungsklasse

private List<Hoge> createList() {
	List<Hoge> list = new ArrayList<>();
	list.add(new Hoge("Hoge 1S", "S"));
	list.add(new Hoge("Hoge 2A", "A"));
	list.add(new Hoge("Hoge 3SS", "SS"));
	list.add(new Hoge("Hoge 4B", "B"));
	list.add(new Hoge("Hoge 5A", "A"));
	list.add(new Hoge("Hoge 6SS", "SS"));
	return list;
}

Es ist ein Beispiel, einfach ist das beste w So sieht es also aus.

Dies mit Priorität SS > S > A > B Versuchen Sie, in der Reihenfolge von zu arrangieren

Versuche zu rennen

public static void main(String[] args) {
	List<Hoge> list = createList();

	Stream.of(
		list.stream().filter(o -> "SS".equals(o.priority)),
		list.stream().filter(o -> "S".equals(o.priority)),
		list.stream().filter(o -> "A".equals(o.priority)),
		list.stream().filter(o -> "B".equals(o.priority))
	).flatMap(s -> s).forEach(h -> System.out.println(h.name));
}

Die einzige besondere Erwähnung ist die Verwendung von flatMap, die auf den ersten Blick nutzlos aussieht. Wenn Sie dies hier nicht verwenden, ist es Stream \ <Stream \ <Hoge > >. Hier möchte ich es Stream \ <Hoge > machen, also sieht es so aus.

• Die createList-Methode ist statisch ~

Ausführungsergebnis

Hoge 3SS Hoge 6SS Hoge 1S Hoge 2A Hoge 5A Hoge 4B

Vorerst abgeschlossen.

Spiel mit

Stream.of(
	list.stream().filter(o -> "SS".equals(o.priority)),
	list.stream().filter(o -> "S".equals(o.priority)),
	list.stream().filter(o -> "A".equals(o.priority)),
	list.stream().filter(o -> "B".equals(o.priority))
)

Ich möchte etwas gegen diesen Teil unternehmen ...

Versuchen Sie vorerst, es durch den Prädikattyp zu ersetzen.

	Predicate<Hoge> isSs = o -> "SS".equals(o.priority);
	Predicate<Hoge> isS = o -> "S".equals(o.priority);
	Predicate<Hoge> isA = o -> "A".equals(o.priority);
	Predicate<Hoge> isB = o -> "B".equals(o.priority);
	Stream.of(
		list.stream().filter(isSs),
		list.stream().filter(isS),
		list.stream().filter(isA),
		list.stream().filter(isB)
	).flatMap(s -> s).forEach(h -> System.out.println(h.name));

Es ist subtil. Es ist ein bisschen, dass es 4 Prädikattypen gibt. ..

Weiter optimieren

Die vier Funktionen des Prädikattyps ändern nur den Teil, bevor er gleich ist. Ich frage mich, ob ich es schaffen kann, nur diesen String-Teil zu übergeben.

Es ist so, als würde man einen String übergeben und einen Prädikattyp zurückgeben. Lassen Sie es uns also in den Funktionstyp einschließen.

	Function<String, Predicate<Hoge>> priority = p -> new Predicate<Hoge>(){
		@Override
		public boolean test(Hoge t) {
			return p.equals(t.priority);
		}
	};

	Stream.of(
		list.stream().filter(priority.apply("SS")),
		list.stream().filter(priority.apply("S")),
		list.stream().filter(priority.apply("A")),
		list.stream().filter(priority.apply("B"))
	).flatMap(s -> s).forEach(h -> System.out.println(h.name));

Ich habe es einmal in einer anonymen Klasse geschrieben, aber ich denke, es ist viel besser.

Konvertieren Sie anonyme Klassen in Lambda.

Function<String, Predicate<Hoge>> priority = p -> t -> { return p.equals(t.priority); }

Sie brauchen nicht einmal eine Rückgabe. Lass es uns nehmen.

	Function<String, Predicate<Hoge>> priority = p -> t -> p.equals(t.priority);

	Stream.of(
		list.stream().filter(priority.apply("SS")),
		list.stream().filter(priority.apply("S")),
		list.stream().filter(priority.apply("A")),
		list.stream().filter(priority.apply("B"))
	).flatMap(s -> s).forEach(h -> System.out.println(h.name));

Es stellte sich heraus, dass es so etwas war. Wird es ein bisschen überschaubarer sein?