Add U.count(iterable, predicate).

Author: javadev

src/main/java/com/github/underscore/U.java

@@ -552,6 +552,20 @@ public boolean any(final Predicate<T> pred) {
         return some(iterable, pred);
     }
 
+    public static <E> int count(final Iterable<E> iterable, final Predicate<E> pred) {
+        int result = 0;
+        for (E item : iterable) {
+            if (pred.test(item)) {
+                result += 1;
+            }
+        }
+        return result;
+    }
+
+    public int count(final Predicate<T> pred) {
+        return count(iterable, pred);
+    }
+
     public static <E> boolean contains(final Iterable<E> iterable, final E elem) {
         return some(iterable, new Predicate<E>() {
             @Override
@@ -2324,6 +2338,10 @@ public Chain<Boolean> some(final Predicate<T> pred) {
             return new Chain<Boolean>(U.some(list, pred));
         }
 
+        public Chain<Integer> count(final Predicate<T> pred) {
+            return new Chain<Integer>(U.count(list, pred));
+        }
+
         public Chain<Boolean> contains(final T elem) {
             return new Chain<Boolean>(U.contains(list, elem));
         }

src/main/java/com/github/underscore/lodash/U.java

@@ -299,6 +299,10 @@ public Chain<Boolean> some(final Predicate<T> pred) {
             return new Chain<Boolean>(U.some(value(), pred));
         }
 
+        public Chain<Integer> count(final Predicate<T> pred) {
+            return new Chain<Integer>(U.count(value(), pred));
+        }
+
         public Chain<Boolean> contains(final T elem) {
             return new Chain<Boolean>(U.contains(value(), elem));
         }

src/test/java/com/github/underscore/CollectionsTest.java

@@ -950,6 +950,61 @@ public void include() {
         assertTrue(result);
     }
 
+/*
+_.count([1, 2, 3, 4], function(num) { return num % 2 === 0; }); // 2
+_.count([1, 2, 3, 4], function(num) { return num < 5; }); // 4
+*/
+    @Test
+    @SuppressWarnings("unchecked")
+    public void count() {
+        final int result1 = U.count(asList(1, 2, 3, 4),
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item % 2 == 0;
+            }
+        });
+        final int result1obj = new U(asList(1, 2, 3, 4))
+            .count(
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item % 2 == 0;
+            }
+        });
+        final int result1chain = U.chain(asList(1, 2, 3, 4))
+            .count(
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item % 2 == 0;
+            }
+        }).item();
+        final int result2 = U.count(asList(1, 2, 3, 4),
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item < 5;
+            }
+        });
+        final int result2obj = new U(asList(1, 2, 3, 4))
+            .count(
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item < 5;
+            }
+        });
+        final int result2chain = U.chain(asList(1, 2, 3, 4))
+            .count(
+            new Predicate<Integer>() {
+            public boolean test(Integer item) {
+                return item < 5;
+            }
+        }).item();
+        assertEquals(2, result1);
+        assertEquals(2, result1obj);
+        assertEquals(2, result1chain);
+        assertEquals(4, result2);
+        assertEquals(4, result2obj);
+        assertEquals(4, result2chain);
+    }
+
 /*
 _.contains([1, 2, 3], 3);
 => true

src/test/java/com/github/underscore/lodash/LodashTest.java

@@ -752,6 +752,8 @@ public void accept(String str) {
             public boolean test(String str) { return true; } });
         U.chain(new String[] {""}).some(new Predicate<String>() {
             public boolean test(String str) { return true; } });
+        U.chain(new String[] {""}).count(new Predicate<String>() {
+            public boolean test(String str) { return true; } });
         U.chain(new String[] {""}).contains("");
         U.chain(new String[] {""}).invoke("toString", Collections.emptyList());
         U.chain(new String[] {""}).invoke("toString");