Replaced stream() functionality by loops (closes #40)

strain/example.java

@@ -1,16 +1,26 @@
-import java.util.Collection;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 public class Strain {
 
-	public static <T> Collection<T> keep(Collection<T> coll, Predicate<T> func)
-	{
-		return coll.stream().filter(func).collect(Collectors.toList());
+	public static <T> List<T> keep(List<T> collection, Predicate<T> predicate) {
+		return filter(collection, predicate);
 	}
 
-	public static <T> Collection<T> discard(Collection<T> coll, Predicate<T> func)
-	{
-		return coll.stream().filter(func.negate()).collect(Collectors.toList());
+	public static <T> List<T> discard(List<T> collection, Predicate<T> predicate) {
+		return filter(collection, predicate.negate());
+	}
+
+	public static <T> List<T> filter(List<T> collection, Predicate<T> predicate) {
+		List<T> filteredCollection = new ArrayList<>();
+
+		for (T item : collection) {
+			if (predicate.test(item)) {
+				filteredCollection.add(item);
+			}
+		}
+
+		return filteredCollection;
 	}
 }

strain/src/test/java/StrainTest.java

@@ -7,115 +7,115 @@ import java.util.List;
 
 public class StrainTest {
 
-	@Test
-	public void emptyKeep() {
-		List<Integer> expected = new LinkedList<>();
-		List<Integer> test = new LinkedList<>();
-		Assert.assertEquals(expected, Strain.keep(test, x -> x < 10));
-	}
+    @Test
+    public void emptyKeep() {
+        List<Integer> input = new LinkedList<>();
+        List<Integer> expectedOutput = new LinkedList<>();
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
+    }
 
-	@Test
-	public void keepEverything() {
-		List<Integer> expected = Arrays.asList(1, 2, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x < 10));
-	}
+    @Test
+    public void keepEverything() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 2, 3);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
+    }
 
-	@Test
-	public void keepFirstAndLast() {
-		List<Integer> expected = Arrays.asList(1, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x % 2 != 0));
-	}
+    @Test
+    public void keepFirstAndLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 3);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 != 0));
+    }
 
-	@Test
-	public void keepNeitherFirstNorLast() {
-		List<Integer> expected = Arrays.asList(2, 4);
-		List<Integer> test = Arrays.asList(1, 2, 3, 4, 5);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x % 2 == 0));
-	}
+    @Test
+    public void keepNeitherFirstNorLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> expectedOutput = Arrays.asList(2, 4);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 == 0));
+    }
 
-	@Test
-	public void KeepStrings() {
-		List<String> words = Arrays
-				.asList("apple zebra banana zombies cherimoya zelot".split(" "));
-		List<String> expected = Arrays.asList("zebra", "zombies", "zelot");
-		Assert.assertEquals(expected,
-				Strain.keep(words, x -> x.startsWith("z")));
-	}
+    @Test
+    public void KeepStrings() {
+        List<String> words = Arrays
+                .asList("apple zebra banana zombies cherimoya zelot".split(" "));
+        List<String> expectedOutput = Arrays.asList("zebra", "zombies", "zelot");
+        Assert.assertEquals(expectedOutput,
+                Strain.keep(words, x -> x.startsWith("z")));
+    }
 
-	@Test
-	public void KeepArrays() {
-		List<List<Integer>> actual = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(5, 5, 5), 
-				Arrays.asList(5, 1, 2),
-				Arrays.asList(2, 1, 2), 
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(2, 2, 1), 
-				Arrays.asList(1, 2, 5));
-		List<List<Integer>> expected = Arrays.asList(
-				Arrays.asList(5, 5, 5),
-				Arrays.asList(5, 1, 2), 
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(1, 2, 5));
-		Assert.assertEquals(expected,
-				Strain.keep(actual, col -> col.contains(5)));
-	}
+    @Test
+    public void KeepArrays() {
+        List<List<Integer>> actual = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(2, 2, 1),
+                Arrays.asList(1, 2, 5));
+        List<List<Integer>> expectedOutput = Arrays.asList(
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(1, 2, 5));
+        Assert.assertEquals(expectedOutput,
+                Strain.keep(actual, col -> col.contains(5)));
+    }
 
-	@Test
-	public void emptyDiscard() {
-		List<Integer> expected = new LinkedList<>();
-		List<Integer> test = new LinkedList<>();
-		Assert.assertEquals(expected, Strain.discard(test, x -> x < 10));
-	}
+    @Test
+    public void emptyDiscard() {
+        List<Integer> input = new LinkedList<>();
+        List<Integer> expectedOutput = new LinkedList<>();
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x < 10));
+    }
 
-	@Test
-	public void discardNothing() {
-		List<Integer> expected = Arrays.asList(1, 2, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x > 10));
-	}
+    @Test
+    public void discardNothing() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 2, 3);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x > 10));
+    }
 
-	@Test
-	public void discardFirstAndLast() {
-		List<Integer> expected = Arrays.asList(2);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x % 2 != 0));
+    @Test
+    public void discardFirstAndLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(2);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x % 2 != 0));
 
-	}
+    }
 
-	@Test
-	public void discardNeitherFirstNorLast() {
-		List<Integer> expected = Arrays.asList(1, 3, 5);
-		List<Integer> test = Arrays.asList(1, 2, 3, 4, 5);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x % 2 == 0));
-	}
+    @Test
+    public void discardNeitherFirstNorLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> expectedOutput = Arrays.asList(1, 3, 5);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x % 2 == 0));
+    }
 
-	@Test
-	public void discardStrings() {
-		List<String> words = Arrays
-				.asList("apple zebra banana zombies cherimoya zelot".split(" "));
-		List<String> expected = Arrays.asList("apple", "banana", "cherimoya");
-		Assert.assertEquals(expected,
-				Strain.discard(words, x -> x.startsWith("z")));
-	}
+    @Test
+    public void discardStrings() {
+        List<String> words = Arrays
+                .asList("apple zebra banana zombies cherimoya zelot".split(" "));
+        List<String> expectedOutput = Arrays.asList("apple", "banana", "cherimoya");
+        Assert.assertEquals(expectedOutput,
+                Strain.discard(words, x -> x.startsWith("z")));
+    }
 
-	@Test
-	public void discardArrays() {
-		List<List<Integer>> actual = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(5, 5, 5),
-				Arrays.asList(5, 1, 2),
-				Arrays.asList(2, 1, 2),
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(2, 2, 1),
-				Arrays.asList(1, 2, 5));
-		List<List<Integer>> expected = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(2, 1, 2),
-				Arrays.asList(2, 2, 1));
-		Assert.assertEquals(expected,
-				Strain.discard(actual, col -> col.contains(5)));
-	}
+    @Test
+    public void discardArrays() {
+        List<List<Integer>> actual = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(2, 2, 1),
+                Arrays.asList(1, 2, 5));
+        List<List<Integer>> expectedOutput = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(2, 2, 1));
+        Assert.assertEquals(expectedOutput,
+                Strain.discard(actual, col -> col.contains(5)));
+    }
 }