Traitement de flux d'inversion de liste Java étonnamment profond

Notez qu'il était étonnamment difficile d'inverser la liste en Java.

[1, 2, 3].reverse

En ruby, le tableau est facilement inversé comme indiqué dans ↑. Je pensais que Java aurait également l'inversion en standard, comme l'API Stream,

list.stream().reverse();

Je ne pouvais pas faire ça. J'ai recherché divers éléments liés au flux, mais je n'ai pas pu les trouver, donc j'étais en difficulté.

Pour le moment, la folie de tourner la liste du côté opposé avec l'instruction for pour générer une liste inversée. .. ..

J'ai donc essayé de résumer ** 3 façons d'inverser la liste **.

1. Comment utiliser les collections les plus courantes.

Il s'agit de la méthode la plus standard fournie par la bibliothèque standard.

List<String> list = Arrays.asList("a", "b", "c", "d", "e", "f");
Collections.reverse(list);
// list = [f, e, d, c, b, a]

Notez que ce processus modifie la «liste» de manière destructive. À propos, Collections est une collection de processus pour manipuler des collections telles que List et Set. Par exemple, «shuffle» et «sort».

2. Comment utiliser Deque

Si vous traversez fréquemment la structure vers la droite et la gauche, il est judicieux de la transformer en liste bidirectionnelle.

Deque<String> deque = new LinkedList<>(list);
//commande
for(String s: deque) {
	//Traitement des s
}
//Inverser
Iterator<String> iter = deque.descendingIterator();
while(iter.hasNext()) {
	String s = iter.next();
	//Traitement des s
}

Cependant, l'inconvénient est que cela devient une petite écriture héritée. .. ..

3. Comment utiliser l'API Collect of Stream

Vous pouvez également utiliser l'API Stream. Le traitement de flux lui-même est fondamentalement indépendant de l'ordre des éléments et permet de traiter indépendamment pour chaque élément. D'un autre côté, nous ne sommes pas doués pour le traitement qui implique des relations de commande. Cependant, la commande peut être garantie et peut être utilisée pour inverser.

//Un peu long. .. .. Cependant, si le processus d'obtention de la liste d'ordre inverse n'apparaît pas plusieurs fois
List<String> reversedList = list.stream().collect(ArrayList::new, (l, e) -> l.add(0, e), (l, subl) -> l.addAll(0, subl));

collect est une méthode qui décrit le processus d'agrégation.

0. ʻArrayList :: new` détermine la classe d'agrégation.
1. (l, e) -> l.add (0, e) est le corps principal du traitement d'agrégation. Ajoutez maintenant un élément au début de la liste l.
2. (l, subl) -> l.addAll (0, subl) est un processus récapitulatif pendant l'exécution parallèle. Résumez dans le premier argument. (Lors du traitement parallèle, la liste est traitée en la divisant de manière appropriée et les résultats agrégés sont générés pour chacun. Il est nécessaire d'intégrer ces multiples résultats.)

C'est une chose simple à faire, mais c'est difficile à écrire. ** Je veux vraiment écrire comme suit. ** **

List<String> reversedList = strs.stream().collect(MyCollectors.reverse());

Dans ce cas, préparez la classe d'implémentation Collection suivante.

MyCollectors.java

public class MyCollectors {

	public static <T> Collector<T, List<T>, List<T>> reverse() {

		return new Collector<T, List<T>, List<T>>() {
			@Override
			public Supplier<List<T>> supplier() {
				return ArrayList::new;
			}

			@Override
			public BiConsumer<List<T>, T> accumulator() {
				return (l, e) -> l.add(0, e);
			}

			@Override
			public BinaryOperator<List<T>> combiner() {
				return (l, subl) -> {
					l.addAll(0, subl);
					return l;
				};
			}

			@Override
			public Function<List<T>, List<T>> finisher() {
				//Aucun processus d'agrégation final n'est requis, la liste est donc renvoyée telle quelle
				return l -> l;
			}

			@Override
			public Set<Characteristics> characteristics() {
				//Traitement parallèle possible
				return EnumSet.of(Characteristics.CONCURRENT);
			}
		};
	}
}

C'est un problème à écrire, mais une fois que vous l'avez écrit, vous pouvez facilement l'utiliser avec le traitement de flux.

Bonus) Dans certains cas, il n'est pas nécessaire de générer une liste inversée

Si la liste inversée elle-même est un produit intermédiaire, il n'est pas nécessaire d'inverser la liste. Par exemple, si vous souhaitez combiner des chaînes dans l'ordre inverse, vous n'avez pas besoin de créer une liste inversée, procédez comme suit:

List<String> strs = Arrays.asList("a", "b", "c", "d", "e", "f");
String reverse = strs.stream().reduce((e1, e2) -> e2.concat(e1)).get();
// reverse = "fedcba"

Résumé

Dans le cas de Java, la méthode chain ne peut pas être facilement exécutée avec un seul mot, mais il existe trois méthodes principales. 0. Utilisez la norme Java Collections.reverse

1. Utilisez Deque
2. Utilisez l'API Stream Il semble que vous deviez utiliser la méthode qui convient au processus individuel.