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 consisterait à utiliser Stream.iterate() de la manière 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éplacé N éléments vers la droite, selon la liste source.

C'est aussi efficace, parce que la méthode List.sublist() renvoie une view 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 vaut mieux prendre l'une ou l'autre des approches de @sprinter, puisque 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 de sources, de nombreux wrappers seraient créés. Et cela pourrait finir par être coûteux, ou même générer un StackOverflowError.

Si vous êtes prêt à utiliser une bibliothèque tierce, puis jOOλ 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]

Avertissement: 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 index 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());