Java flux de filtrer les éléments de l'indice spécifique

Je suis à la recherche d'une manière concise pour filtrer les éléments d'une Liste à un indice particulier. Mon exemple d'entrée ressemble à ceci:

List<Double> originalList = Arrays.asList(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
List<Integer> filterIndexes = Arrays.asList(2, 4, 6, 8);

Je veux filtrer les éléments à l'index 2, 4, 6, 8. J'ai une boucle for qui ignore les éléments qui correspondent à l'indice, mais j'espérais qu'il y aurait un moyen facile de le faire à l'aide de flux. Le résultat final devrait ressembler que:

List<Double> filteredList = Arrays.asList(0.0, 1.0, 3.0, 5.0, 7.0, 9.0, 10.0);
  • C'est incroyablement facile à l'aide d'un for boucle et remove(int). Ne pas utiliser les flux pour tout.
  • Merci @PaulBoddington. Venant de .Travail NET, je suis habitué à l'utilisation de LINQ pour la plupart du tableau/liste d'activités et de ses facile de faire cela à l'aide de LINQ donc espérais quelque chose de similaire serait en Java 8 flux
  • Les ruisseaux et toute forme d'indexation ne s'entendent pas bien du tout.
  • Ces explicite de la création de la matrice des déclarations comme new Double[] {…} et new Integer[] {…} sont obsolètes. Simplement utiliser, par exemple, List<Integer> filterIndexes = Arrays.asList(2, 4, 6, 8);
  • J'ai posté une réponse à l'aide de deux, remove(int) et des ruisseaux.
InformationsquelleAutor Vedanth | 2016-03-29
  1. 18

    Vous pouvez générer un IntStream pour imiter les indices de la liste d'origine, puis de supprimer ceux qui sont dans le filteredIndexes liste et puis la carte de ces indices à leur élément correspondant dans la liste (une meilleure façon serait d'avoir un HashSet<Integer> pour les indices, car ils sont uniques, par définition, de sorte que contains est une constante de temps de l'opération).

    List<Double> filteredList = 
    IntStream.range(0, originalList.size())
             .filter(i -> !filterIndexes.contains(i))
             .mapToObj(originalList::get)
             .collect(Collectors.toList());
    InformationsquelleAutor Alexis C.
  2. 5

    Si votre filteredIndexes liste est prétriés, vous pouvez éviter de vérifier chaque élément de cette façon:

    List<Double> filteredList = IntStream.rangeClosed(0, filterIndexes.size())
    .mapToObj(idxPos -> idxPos == 0 
           ? originalList.subList(0, filterIndexes.get(idxPos)) 
           : idxPos == filterIndexes.size() 
           ? originalList.subList(filterIndexes.get(idxPos-1)+1, originalList.size()) 
           : originalList.subList(filterIndexes.get(idxPos-1)+1, filterIndexes.get(idxPos)))
    .flatMap(List::stream)
    .collect(Collectors.toList());

    Ici, nous créons un certain nombre de sous-listes qui contiennent tous les éléments entre les filtrée indices, puis aplatir un peu dans la seule liste finale. Pour la grande entrée (par exemple, un million de nombres) cette solution pourrait être beaucoup plus rapide que celle proposée par @AlexisC.

    InformationsquelleAutor Tagir Valeev
  3. 2

    Si vous triez vos index décroissant, alors vous pouvez utiliser java.util.List.remove(int) pour supprimer les éléments.

    List<Double> originalList = new ArrayList<>(Arrays.asList(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0));
List<Integer> filterIndexes = Arrays.asList(2, 4, 6, 8);

filterIndexes.stream()

    //remove higher indixes first, because each remove affects all indexes to the right
    .sorted(Comparator.reverseOrder())

    //make sure to use remove(int) not remove(Object) in java.util.List to use indexes
    .mapToInt(Integer::intValue)

    //remove each index
    .forEach(originalList::remove);

//print results
originalList.forEach(System.out::println);
    • N'utilisez pas de .mapToInt(Integer::valueOf). Ce qui fonctionne, mais la conversion de la Integer objet d'une int de la valeur à transmettre à Integer valueOf(int) pour obtenir de nouveau un Integer objet qui est ensuite auto-unboxed à un int que vous utilisez mapToInt. Vous avez sûrement envie soit, .mapToInt(i->i) ou .mapToInt(Integer::intValue), l'exécution d'une seule unboxing, à la place.
    • Merci! Integer::intValue ce que je cherchais. J'ai aussi essayé Function.identity() mais cela ne fonctionne pas.
    • Oui, Function.identity() renvoie une Function plutôt qu'un ToIntFunction, donc qui ne fonctionne pas comme le type classique de compatibilité des règles qui s'appliquent ici, plutôt que la signature fonctionnelle correspondant lors de l'utilisation de x -> x directement...
    InformationsquelleAutor slartidan