Prenez chaque nième élément d'un flux Java 8

MODIFIER-Nov 28, 2017

Comme utilisateur @Emiel suggère dans les commentaires, la meilleure façon de le faire serait d'utiliser Stream.itearate pour conduire la liste à travers une séquence d'indices:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

int skip = 3;
int size = list.size();
// Limit to carefully avoid IndexOutOfBoundsException
int limit = size / skip + Math.min(size % skip, 1);

List<Integer> result = Stream.iterate(0, i -> i + skip)
    .limit(limit)
    .map(list::get)
    .collect(Collectors.toList());

System.out.println(result); // [1, 4, 7, 10]

Cette approche n'a pas les inconvénients de ma réponse précédente, qui vient ci-dessous (j'ai décidé de la garder pour des raisons historiques).

Une Autre approche serait d'utiliser Stream.iterate() de la façon suivante:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

int skip = 3;
int size = list.size();
// Limit to carefully avoid IndexOutOfBoundsException
int limit = size / skip + Math.min(size % skip, 1);

List<Integer> result = Stream.iterate(list, l -> l.subList(skip, l.size()))
    .limit(limit)
    .map(l -> l.get(0))
    .collect(Collectors.toList());

System.out.println(result); // [1, 4, 7, 10]

, L'idée est de créer un flux de sous-listes, chacune sauter les premiers N éléments du précédent (N=3 dans l'exemple).

Nous devons limiter le nombre d'itérations afin de ne pas essayer d'obtenir une sous-liste dont les limites sont hors de portée.

Ensuite, nous mappons nos sous-listes à leur premier élément et collectons nos résultats. Garder le premier élément de chaque sous-liste fonctionne comme prévu car l'index begin de chaque sous-liste est décalé N éléments vers la droite, selon la liste source.

Ceci est également efficace, parce que la méthode List.sublist() renvoie unview de la liste d'origine, ce qui signifie qu'elle ne crée pas de nouveau List pour chaque itération.

EDIT: Après un certain temps, j'ai appris qu'il est préférable de prendre l'une des approches de @sprinter, car subList() crée un wrapper autour de la liste d'origine. Cela signifie que la deuxième liste du volet serait un wrapper de la première liste, le troisième de la liste du volet serait un wrapper de la deuxième liste (ce qui est déjà un emballage!), et ainsi de suite...

Bien que cela puisse fonctionner pour les petites et moyennes listes, il convient de noter que pour une très grande liste source, de nombreux wrappers seraient créés. Et cela pourrait finir par coûter cher, ou même générer un StackOverflowError.

Si vous êtes prêt à utiliser une bibliothèque tierce, alors Joooλ offre des fonctionnalités utiles comme zipWithIndex():

Chaque deuxième élément

System.out.println(
Seq.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
   .zipWithIndex()             // This produces a Tuple2(yourvalue, index)
   .filter(t -> t.v2 % 2 == 0) // Filter by the index
   .map(t -> t.v1)             // Remove the index again
   .toList()
);

[1, 3, 5, 7, 9]

Chaque troisième élément

System.out.println(
Seq.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
   .zipWithIndex()
   .filter(t -> t.v2 % 3 == 0)
   .map(t -> t.v1)
   .toList()
);

[1, 4, 7, 10]

Disclaimer: Je travaille pour la société derrière jOOλ

, Vous pouvez également utiliser flatMap, avec une fonction personnalisée qui ignore des éléments:

private <T> Function<T, Stream<T>> everyNth(int n) {
  return new Function<T, Stream<T>>() {
    int i = 0;

    @Override
    public Stream<T> apply(T t) {
      if (i++ % n == 0) {
        return Stream.of(t);
      }
      return Stream.empty();
    }
  };
}

@Test
public void everyNth() {
  assertEquals(
    Arrays.asList(1, 4, 7, 10),
    IntStream.rangeClosed(1, 10).boxed()
      .flatMap(everyNth(3))
      .collect(Collectors.toList())
  );
}

Il a l'avantage de travailler avec des flux non indexés. Mais ce n'est pas une bonne idée de l'utiliser avec des flux parallèles (peut-être passer à un entier atomique pour i).

Essayez ceci.

    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    int[] n = {0};
    List<Integer> result = list.stream()
        .filter(x -> n[0]++ % 3 == 0)
        .collect(Collectors.toList());
    System.out.println(result);
    // -> [1, 4, 7, 10]

Voici le code par AbacusUtil

Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .filter(MutableInt.of(0), (e, idx) -> idx.getAndDecrement() % 2 == 0)
        .println();
// output: 1, 3, 5, 7, 9

Ou si l'index est requis:

Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
      .indexed().filter(i -> i.index() % 2 == 0).println();
// output: [0]=1, [2]=3, [4]=5, [6]=7, [8]=9

Déclaration： Je suis le développeur de AbacusUtil.

Utiliser la goyave:

Streams
    .mapWithIndex(stream, SimpleImmutableEntry::new)
    .filter(entry -> entry.getValue() % 3 == 0)
    .map(Entry::getKey)
    .collect(Collectors.toList());