Znajdź, który element strumienia nie pasuje do podanego predykatu w allmatch

Question

Chcę dowiedzieć się, który element nie spełnia predykatu w przypadku allmatch.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); 
boolean isEven = numbers.stream().allMatch(n-> n % 2 == 0); 

Tutaj isEven jest false, jako elementem 1 nie predykat.

mogę używać forEach nad strumieniem znaleźć który element zawiedzie jak:

numbers.stream().forEach(n -> { 
      if (n % 2 != 0) 
       System.out.println(n + "is Odd"); 
     }); 

Czy istnieje sposób, aby dowiedzieć się, które elementy nie predykat w allmatch kiedy wraca false?

Answer 1

Należy pamiętać, że allMatch jest operacją zwarcia, co oznacza, że ​​API strumienia może zwrócić wartość false bez znajdowania wszystkich elementów, które nie przejdą testu.

Jeśli więc chcesz znaleźć wszystkie wadliwych elementów, być może będziesz musiał wykonać więcej pracy niż zwykły allMatch (jak pokazują inne odpowiedzi). Jednakże, jeśli tylko dbać, aby znaleźć jeden element, który nie przejdzie testu, należy findAny następująco:

Optional<Integer> odd = numbers.stream() 
    .filter(n -> n % 2 != 0) 
    .findAny(); 

boolean isEven = !odd.isPresent(); 

odd.ifPresent(x -> System.out.println(x + " is odd")); 

Answer 2

Na tym przykładzie:

Map<Boolean, List<Integer>> map = numbers.stream() 
      .collect(Collectors.partitioningBy(x -> x % 2 == 0)); 

    System.out.println(map); // {false=[1, 3, 5], true=[2, 4]} 

mógłby się po prostu zalogować się na przykład także:

boolean isEven = numbers.stream().allMatch(n -> { 
     boolean test = n % 2 == 0; 
     if (!test) { 
      System.out.println("Failed = " + n); 
     } 
     return test; 
    }); 

Ale to może wprowadzić interesujące rezultaty, jeśli uruchomić go w parallel. Wynik byłby nie do przewidzenia. To jest isEven nadal będzie zwracać poprawny wynik, ale to, co widzisz poprzez Syso jest całkowicie nie do przewidzenia. Mogą być:

Failed = 3 
Failed = 1 
Failed = 5 

A na innej perspektywie mogą być:

Failed = 3 

Answer 3

Spróbuj:

List<Integer> notMatchElements = numbers.stream() 
       .filter(n -> n % 2 == 0) 
       .collect(Collectors.toList()); 

Jeśli długość notMatchElements równa 0 -> wszystkie mecze

Else -> ty nie pasuje do elementów

Answer 4

Trzeba rozdzielić tych dwóch działań (filtrowanie i weryfikacji cały mecz na dwie akcje)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); 
List<Integer> notMatched = numbers 
          .stream() 
          .filter(n-> n % 2 != 0) 
          .collect(Collectors.toList()); 
boolean isEven = notMatched.isEmpty(); 

Answer 5

proponuję użyć tego podejścia:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); 

List<Integer> badNumbers = numbers.stream().filter(n -> n % 2 != 0).collect(Collectors.toList()); 

W tym przypadku badNumbers będzie pusta, jeśli wszystkie elementy spełniają n%2 = 0 inaczej będzie zawierać wartości, które nie.

Answer 6

Coś trzeba wyjaśnić: a boolean nie jest Predicate.boolean jest rzeczownik, ale Predicate jest orzecznik. więc Predicate więcej tak:

IntPredicate isEven = n -> n % 2 == 0; 

boolean numbersAreEven = numbers.stream().allMatch(isEven); 

IF trzeba odwrócić się Predicate można korzystając Predicate#negate, na przykład:

IntPredicate isOdd = isEven.negate(); 

boolean numbersAreOdd = numbers.stream().allMatch(isOdd); 

IF chcesz wymienić wszystkie numery nieparzyste, powinieneś użyć Stream#filter, na przykład:

numbers.stream().filter(isOdd).forEach(System.out::println); 

IF chcesz znaleźć pierwszą liczbę nieparzystą, można użyć Stream#findFirst, na przykład:

Number odd = numbers.stream().filter(isOdd).findFirst().orElse(null); 

IF chcesz znaleźć pierwszą nieparzystą liczbę niezależnie od elementów zamówienia, można użyć Stream#findAny na przykład:

Number odd = numbers.stream().filter(isOdd).findAny().orElse(null); 

Uwaga: zarówno Stream#findAny i Stream#findFirst są short-circuiting terminal operation, co oznacza, że ​​w chory zjazd po spełnieniu dowolnego warunku intermediate operation.