[JAVA] Trier dans la liste, pour mémo personnel

environnement

Java sur cette page 1.8 Il est assemblé avec.

Ce que vous essayez de faire

-Trier les classes de la liste dans un ordre spécifique ・ Essayez d'utiliser Stream ・ N'utilisez pas le comparateur

• Pour savoir comment utiliser Composer, veuillez vous référer à l'article de Swordone dans la section commentaires en bas de page!

Je vais l'essayer tout de suite

Tout d'abord, la classe dans 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;
	}
}

Comme ça. Il n'y a pas de getter / setter car c'est gênant.

Classe de génération de liste

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

C'est un échantillon, simple est le meilleur w Donc ça ressemble à ça.

Ceci avec priorité SS > S > A > B Essayez d'organiser dans l'ordre de

Essayez de courir

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

La seule mention spéciale est comment utiliser flatMap, qui semble inutile à première vue? Si vous ne l'utilisez pas ici, ce sera Stream \ <Stream \ <Hoge > >. Ici, je veux le faire Stream \ <Hoge >, donc ça ressemble à ceci.

• La méthode createList est statique ~

Résultat d'exécution

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

Terminé pour le moment.

Joue avec

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

Je veux faire quelque chose à propos de cette partie ...

Pour le moment, essayez de le remplacer par le type Predicate.

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

C'est subtil. C'est un peu qu'il existe 4 types de prédicat. ..

Tweak plus loin

Les quatre fonctions du type Prédicat ne modifient que la pièce avant égale, Je me demande si je peux réussir à ne passer que cette partie String?

C'est comme passer une chaîne et renvoyer un type de prédicat. Alors, incluons-le dans le type Function.

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

Je l'ai écrit une fois dans une classe anonyme, mais je pense que c'est beaucoup mieux.

Convertissez les classes anonymes en lambda.

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

Vous n'avez même pas besoin d'un retour. Prenons-le.

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

Il s'est avéré être quelque chose comme ça. Sera-ce un peu plus gérable?