feat(predicates): overloads for collections

Author: Reko Jokelainen

src/main/java/com/nitorcreations/predicates/NStringPredicates.java

@@ -1,11 +1,13 @@
 package com.nitorcreations.predicates;
 
-import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
 
 import static com.nitorcreations.predicates.NPredicates.not;
 import static com.nitorcreations.predicates.NPredicates.notNull;
+import static com.nitorcreations.streams.NStreams.asStream;
+import static java.util.Arrays.asList;
 
 public final class NStringPredicates {
     private NStringPredicates() { /** prevent instantiation */}
@@ -69,8 +71,18 @@ public static Predicate<String> contains(String substring) {
      * @return predicate
      */
     public static Predicate<String> containsAll(String... substring) {
+        return containsAll(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string contains all of the substrings in any order
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> containsAll(List<String> substrings) {
         return NPredicates.<String> notNull()
-                .and(s -> Arrays.stream(substring)
+                .and(s -> substrings.stream()
                         .filter(Objects::nonNull)
                         .map(s::contains)
                         .reduce(true, Boolean::logicalAnd));
@@ -83,8 +95,18 @@ public static Predicate<String> containsAll(String... substring) {
      * @return predicate
      */
     public static Predicate<String> containsAny(String... substring) {
+        return containsAny(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string contains any of the substrings
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> containsAny(Iterable<String> substrings) {
         return NPredicates.<String> notNull()
-                .and(s -> Arrays.stream(substring)
+                .and(s -> asStream(substrings)
                         .filter(Objects::nonNull)
                         .anyMatch(s::contains));
     }
@@ -108,6 +130,17 @@ public static Predicate<String> doesNotContain(String substring) {
      * @return predicate
      */
     public static Predicate<String> doesNotContainAnyOf(String... substring) {
-        return not(containsAny(substring)).and(notNull());
+        return doesNotContainAnyOf(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string does not contain any of the the substrings. The predicate will return {@code false}
+     * is target is {@code null}
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> doesNotContainAnyOf(Iterable<String> substrings) {
+        return not(containsAny(substrings)).and(notNull());
     }
 }

src/main/java/com/nitorcreations/streams/NStreams.java

@@ -76,7 +76,9 @@ public static <T> Stream<T> asStream(Iterable<T> iterable) {
      * @return a stream containing the values of the iterable
      */
     public static <T> Stream<T> asStream(Iterable<T> iterable, boolean parallel) {
-        return StreamSupport.stream(iterable.spliterator(), parallel);
+        return Optional.ofNullable(iterable)
+                .map(it -> StreamSupport.stream(it.spliterator(), parallel))
+                .orElse(Stream.empty());
     }
 
     /**

src/test/java/com/nitorcreations/predicates/NCollectionPredicates.java

@@ -2,12 +2,12 @@
 
 import java.util.Arrays;
 import java.util.function.Predicate;
-import java.util.stream.Stream;
 
 import static com.nitorcreations.predicates.NPredicates.*;
 import static com.nitorcreations.streams.NStreams.asStream;
+import static java.util.Arrays.asList;
 
-public class NCollectionPredicates {
+public final class NCollectionPredicates {
     private NCollectionPredicates() { /** prevent instantiation */}
 
 
@@ -47,8 +47,20 @@ public static <T, S extends Iterable<T>> Predicate<S> contains(T element) {
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> containsAll(T... elements) {
-        final Predicate<S> allmatch = Stream.of(elements)
+        return containsAll(asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains all of the target elements (comparison by {@code #equals})
+     * @param elements
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    public static <T, S extends Iterable<T>> Predicate<S> containsAll(Iterable<T> elements) {
+        final Predicate<S> allmatch = asStream(elements)
                 .map(NCollectionPredicates::<T, S>contains)
                 .reduce(notEmpty(), (p1, p2) -> p1.and(p2));
         return  NPredicates.<S>notNull().and(allmatch);
@@ -60,16 +72,28 @@ public static <T, S extends Iterable<T>> Predicate<S> containsAll(T... elements)
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> containsAny(T... elements) {
-        final Predicate<S> anyMatches = Arrays.stream(elements)
+        return containsAny(asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains any of the target elements (comparison by {@code #equals})
+     * @param elements
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    public static <T, S extends Iterable<T>> Predicate<S> containsAny(Iterable<T> elements) {
+        final Predicate<S> anyMatches = asStream(elements)
                 .map(NCollectionPredicates::<T, S>contains)
                 .reduce(never(), (p1, p2) -> p1.or(p2));
         return NPredicates.<S>notNull().and(anyMatches);
     }
 
-
     /**
      * Checks that the iterable is non-null and does not contain the target element (comparison by {@code #equals})
+     * @param element the element
      * @param <T> type of an element
      * @param <S> type of the iterable
      * @return predicate
@@ -80,11 +104,24 @@ public static <T, S extends Iterable<T>> Predicate<S> doesNotContain(T element)
 
     /**
      * Checks that the iterable is non-null and contains none of target elements
+     * @param elements elements
      * @param <T> type of an element
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAnyOf(T... elements) {
+        return doesNotContainAnyOf(Arrays.asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains none of target elements
+     * @param elements elements
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAnyOf(Iterable<T> elements) {
         return NPredicates.<S>notNull().and(not(containsAny(elements)));
     }
 }

src/test/java/com/nitorcreations/streams/NStreamsTest.java

@@ -24,6 +24,8 @@
 import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.nitorcreations.streams.NStreams.asStream;
 import static com.nitorcreations.TestUtils.invokePrivateConstructor;
@@ -61,6 +63,12 @@ public void iteratorToStream() {
         assertThat(actual).containsExactlyElementsOf(list);
     }
 
+    @Test
+    public void nullToEmptyStream() {
+        final Stream<String> actual = asStream((Iterable<String>) null);
+        assertThat(actual.collect(Collectors.toList())).isEmpty();
+    }
+
     @Test
     public void iteratorToStream_parallel() {
         final List<Integer> actual = asStream(list.iterator(), true).collect(toList());