Quiero ser capaz de aplicar un filtro basado en la booleano pasado.

public static List<Integer> multiplyNumbers(List<Integer> input, boolean ignoreEven){

    return input.stream()
    .filter(number -> !(number%2==0))
    .map(number -> number*2)
    .collect(Collectors.toList());
}

Quiero hacer el filtro de paso basado en la ignoreEven bandera. Si es verdad, ignorar, incluso los números. ¿Cómo puedo hacerlo? Estoy haciendo esto para evitar la duplicación de código

InformationsquelleAutor Nick01 | 2017-07-25

5 Comentarios

  1. 7

    Suena como un sencillo o condición a mí.

    .filter(number -> !ignoreEven || (number % 2 != 0))
    • ¿cómo sería este cambio si que me gustaría un indicador que ignora todo lo demás, incluso los números en base a la necesidad? por ejemplo, ignoreEverythingBut2
  2. 5

    Si usted no desea comprobar ignoreEven para cada elemento, se puede definir el predicado de la misma forma condicional:

    .filter(ignoreEven ? (n -> n % 2 != 0) : (n -> true))
    • En cualquier momento que un ternario evalúa una condición a una constante, siempre simplificado con la aritmética (en este caso, un or)
    • Que requieren la comprobación de ignoreEven para cada elemento. Si usted tiene una alternativa (aparte de JoeC s), por favor elaborados.
    • Creo que #filter(n -> true) seguiría evaluar la expresión lambda para cada elemento de corriente, por lo que la velocidad preocupación es insignificante (sería el mismo que #filter(n -> !ignoreEven) si ignoreEven es falso, que la respuesta anterior, fundamentalmente, evaluar a causa de || vs |)
    • Estoy de acuerdo en que no es necesariamente una mejora importante. Yo sólo quería publicar un enfoque alternativo. Si realmente vamos por el rendimiento, la mejor solución es, probablemente,Stream<Integer> stream = input.stream(); if (ignoreEven) stream = stream.filter(n -> n % 2 != 0); return stream....
  3. 0

    Puede pasar la enfermedad a su multiply(...) método y que se apruebe en filter como se muestra a continuación.

    multiplyNumbers(Arrays.asList(1, 2, 3, 4, 5), (x) -> x % 2 != 0).forEach(System.out::println);
    
    public static List<Integer> multiplyNumbers(List<Integer> input,    
                                                Predicate<Integer> filterCondition){
    
         return input.stream()
                            .filter(filterCondition)
                            .map(number -> number*2)
                            .collect(Collectors.toList());
    }
    • filterCondition debe ser un Predicate<Integer>.
    • Editado. Gracias.
  4. 0

    Puede definir dos métodos auxiliares y componer con ellos usando or() método:

    private static Predicate<Integer> ignoringEven(boolean ignoreEven) {
        return number -> !ignoreEven;
    }
    
    private static Predicate<Integer> ignoringOdd() {
        return number -> (number % 2 != 0);
    }

    Resultado Final:

    return input.stream()
          .filter(ignoringEven(ignoreEven).or(ignoringOdd()))
          .map(number -> number * 2)
          .collect(Collectors.toList());
  5. 0

    Puede utilizar el anyMatch método:

    return swiftTemplateList.stream()
        .map(swiftTemplate -> swiftTemplate.getName())
        .anyMatch(name -> name.equalsIgnoreCase(messageName));

Dejar respuesta

Please enter your comment!
Please enter your name here