Functional Programming

Author: turingfly

Java-8/src/functionalProgramming/BuiltInFunctionalInterfaces.java

@@ -0,0 +1,134 @@
+package functionalProgramming;
+
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 8, 2017 10:31:11 AM
+ *
+ *         A functional interface has exactly one abstract method. This doesn't
+ *         mean that they have only one method. It can still contain default
+ *         methods or static methods
+ *         
+ */
+public class BuiltInFunctionalInterfaces {
+
+	/**
+	 * A Supplier is used when you want to generate or supply values without
+	 * taking any input. A Supplier is often used when constructing new objects.
+	 */
+	public void supplier() {
+		Supplier<LocalDate> s1 = LocalDate::now;
+		Supplier<LocalDate> s2 = () -> LocalDate.now();
+		LocalDate d1 = s1.get();
+		LocalDate d2 = s2.get();
+		System.out.println(d1);
+		System.out.println(d2);
+	}
+
+	/**
+	 * You use a Consumer when you want to do something with a parameter but not
+	 * return any- thing. BiConsumer does the same thing except that it takes
+	 * two parameters.
+	 */
+	public void consumerAndBiconsumer() {
+		// Consumer
+		Consumer<String> c1 = System.out::println;
+		Consumer<String> c2 = x -> System.out.println(x);
+		c1.accept("a");
+		c2.accept("a");
+
+		// BiConsumer
+		Map<String, Integer> map = new HashMap<>();
+		BiConsumer<String, Integer> b1 = map::put;
+		BiConsumer<String, Integer> b2 = (k, v) -> map.put(k, v);
+		b1.accept("chicken", 7);
+		b2.accept("chick", 1);
+		System.out.println(map);
+	}
+
+	/**
+	 * Predicate is often used when filtering or matching
+	 */
+	public void predicateAndBiPredicate() {
+		// Predicate
+		Predicate<String> p1 = String::isEmpty;
+		Predicate<String> p2 = x -> x.isEmpty();
+		System.out.println(p1.test(""));
+		System.out.println(p2.test(""));
+
+		// BiPredicate
+		BiPredicate<String, String> b1 = String::startsWith;
+		BiPredicate<String, String> b2 = (string, prefix) -> string.startsWith(prefix);
+		System.out.println(b1.test("chicken", "chick"));
+		System.out.println(b2.test("chicken", "chick"));
+
+		// default method
+		Predicate<String> egg = s -> s.contains("egg");
+		Predicate<String> brown = s -> s.contains("brown");
+		Predicate<String> brownEggs = egg.and(brown);
+		Predicate<String> otherEggs = egg.and(brown.negate());
+		System.out.println(brownEggs.test("egg brown"));
+		System.out.println(otherEggs.test("egg"));
+	}
+
+	/**
+	 * A Function is responsible for turning one parameter into a value of a
+	 * potentially different type and returning it. Similarly, a BiFunction is
+	 * responsible for turning two parameters into a value and returning it.
+	 */
+	public void functionAndBiFunction() {
+		// Function
+		Function<String, Integer> f1 = String::length;
+		Function<String, Integer> f2 = x -> x.length();
+		System.out.println(f1.apply("cluck")); // 5
+		System.out.println(f2.apply("cluck")); // 5
+
+		// BiFunction
+		BiFunction<String, String, String> b1 = String::concat;
+		BiFunction<String, String, String> b2 = (string, toAdd) -> string.concat(toAdd);
+		System.out.println(b1.apply("baby ", "chick")); // baby chick
+		System.out.println(b2.apply("baby ", "chick")); // baby chick
+
+		// Creating your own Functional Interface
+		// interface TriFunction<T,U,V,R>{R apply(T t,U u,V v);}
+	}
+
+	/**
+	 * 
+	 * UnaryOperator and BinaryOperator are a special case of a function. They
+	 * require all type parameters to be the same type.
+	 */
+	public void unaryOperatorAndBinaryOperator() {
+		// UnaryOperator
+		UnaryOperator<String> u1 = String::toUpperCase;
+		UnaryOperator<String> u2 = x -> x.toUpperCase();
+		System.out.println(u1.apply("chirp"));
+		System.out.println(u2.apply("chirp"));
+
+		// BuiltInFunctionalInterfaces
+		BinaryOperator<String> b1 = String::concat;
+		BinaryOperator<String> b2 = (string, toAdd) -> string.concat(toAdd);
+		System.out.println(b1.apply("baby ", "chick")); // baby chick
+		System.out.println(b2.apply("baby ", "chick")); // baby chick
+	}
+
+	public static void main(String[] args) {
+		BuiltInFunctionalInterfaces b = new BuiltInFunctionalInterfaces();
+		b.supplier();
+		b.consumerAndBiconsumer();
+		b.predicateAndBiPredicate();
+	}
+}

Java-8/src/functionalProgramming/ReturningAnOptional.java

@@ -0,0 +1,29 @@
+package functionalProgramming;
+
+import java.util.Optional;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 8, 2017 12:46:14 PM
+ *
+ */
+public class ReturningAnOptional {
+	public static Optional<Double> average(int... scores) {
+		if (scores.length == 0) {
+			return Optional.empty();
+		}
+		int sum = 0;
+		for (int score : scores)
+			sum += score;
+		return Optional.of((double) sum / scores.length);
+	}
+
+	public static void main(String[] args) {
+		System.out.println(average(90, 100)); // Optional[95.0]
+		System.out.println(average()); // Optional.empty
+		
+		Optional<Double> opt = average(90, 100); if (opt.isPresent())
+			System.out.println(opt.get()); // 95.0
+	}
+}

Java-8/src/functionalProgramming/StreamCommonIntermediateOprations.java

@@ -0,0 +1,84 @@
+package functionalProgramming;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 8, 2017 10:36:14 PM
+ *
+ *         Unlike a terminal operation, intermediate operations deal with
+ *         infinite streams simply by returning an infinite stream
+ */
+public class StreamCommonIntermediateOprations {
+
+	public void test() {
+		// filter()
+		Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
+		s.filter(x -> x.startsWith("m")).forEach(System.out::print); // monkey
+
+		// distinct()
+		Stream<String> sDistinct = Stream.of("duck", "duck", "duck", "goose");
+		sDistinct.distinct().forEach(System.out::print); // duckgoose
+
+		// limit() and skip()
+		Stream<Integer> sSkipLimit = Stream.iterate(1, n -> n + 1);
+		sSkipLimit.skip(5).limit(2).forEach(System.out::print); // 67
+
+		// map()
+		Stream<String> sMap = Stream.of("monkey", "gorilla", "bonobo");
+		sMap.map(String::length).forEach(System.out::print); // 676
+
+		// faltMap()
+		List<String> zero = Arrays.asList();
+		List<String> one = Arrays.asList("Bonobo");
+		List<String> two = Arrays.asList("Mama Gorilla", "Baby Gorilla");
+		Stream<List<String>> animals = Stream.of(zero, one, two);
+		animals.flatMap(l -> l.stream()).forEach(System.out::println);
+
+		// sorted()
+		Stream<String> sSorted = Stream.of("brown-", "bear-");
+		sSorted.sorted().forEach(System.out::print); // bear-brown-
+
+		Stream<String> sSorted2 = Stream.of("brown bear-", "grizzly-");
+		sSorted2.sorted(Comparator.reverseOrder()).forEach(System.out::print); // grizzly-brow-bear-
+
+		// peek()
+		Stream<String> stream = Stream.of("black bear", "brown bear", "grizzly");
+		long count = stream.filter(st -> st.startsWith("g")).peek(System.out::println).count();
+		System.out.println(count); // 1
+
+		List<String> list = Arrays.asList("Toby", "Anna", "Leroy", "Alex");
+		list.stream()
+			.filter(n -> n.length() == 4)
+			.sorted()
+			.limit(2)
+			.forEach(System.out::println);
+		
+		/**
+		 *  1. stream() sends Toby to filter() . filter() sees that the length is good and sends Toby to sorted()
+		 *  . sorted() can’t sort yet because it needs all of the data, so it holds Toby.
+		 *  2. stream() sends Anna to filter() . filter() sees that the length is good and sends Anna to sorted() 
+		 *  . sorted() can’t sort yet because it needs all of the data, so it holds Anna.
+		 *  3. stream() sends Leroy to filter() . filter() sees that the length is not a match, and it takes Leroy out of the assembly line processing.
+		 *  4.stream() sends Alex to filter() . filter() sees that the length is good and sends Alex to sorted() 
+		 *  . sorted() can’t sort yet because it needs all of the data, so it holds Alex. It
+		 *  turns out sorted() does have all of the required data, but it doesn’t know it yet.
+		 *  5. The foreman lets sorted() know that it is time to sort and the sort occurs.
+		 *  6. sorted() sends Alex to limit() . limit() remembers that it has seen one element and
+		 *  sends Alex to forEach() , printing Alex .
+		 *  7. sorted() sends Anna to limit() . limit() remembers that it has seen two elements
+		 *  and sends Anna to forEach() , printing Anna .
+		 *  8. limit() has now seen all of the elements that are needed and tells the foreman. The
+		 *  foreman stops the line, and no more processing occurs in the pipeline.
+		 */
+	}
+
+	public static void main(String[] args) {
+		StreamCommonIntermediateOprations s = new StreamCommonIntermediateOprations();
+		s.test();
+	}
+}

Java-8/src/functionalProgramming/StreamCommonTerminalOperations.java

@@ -0,0 +1,103 @@
+package functionalProgramming;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 8, 2017 9:44:45 PM
+ * 
+ *         You can perform a terminal operation without any intermediate
+ *         operations. Reductions are a special type of terminal operation where
+ *         all of the contents of the stream are combined into a single
+ *         primitive or Object.
+ * 
+ */
+public class StreamCommonTerminalOperations {
+
+	public void test() {
+		// count()
+		Stream<String> s = Stream.of("monkey", "gorilla", "bonobo");
+		System.out.println(s.count()); // 3
+
+		// min() and max()
+		Stream<String> sMin = Stream.of("monkey", "ape", "bonobo");
+		Optional<String> min = sMin.min((s1, s2) -> s1.length() - s2.length());
+		min.ifPresent(System.out::println); // ape
+
+		// findAny() and findFirst()
+		Stream<String> sFind = Stream.of("monkey", "gorilla", "bonobo");
+		Stream<String> infinite = Stream.generate(() -> "chimp");
+		sFind.findAny().ifPresent(System.out::println); // monkey
+		infinite.findAny().ifPresent(System.out::println); // chimp
+
+		// allMatch(), anyMatch() and nonMatch()
+		List<String> list = Arrays.asList("monkey", "2", "chimp");
+		Stream<String> infinite1 = Stream.generate(() -> "chimp");
+		Predicate<String> pred = x -> Character.isLetter(x.charAt(0));
+		System.out.println(list.stream().anyMatch(pred)); // true
+		System.out.println(list.stream().allMatch(pred)); // false
+		System.out.println(list.stream().noneMatch(pred)); // false
+		System.out.println(infinite1.anyMatch(pred)); // true
+
+		// forEach()
+		Stream<String> sForEach = Stream.of("Monkey", "Gorilla", "Bonobo");
+		sForEach.forEach(System.out::print); // MonkeyGorillaBonobo
+
+		// reduce()
+		// The most common ways of doing a reduction is to start with an initial
+		// value and keep merging it with the next value
+		Stream<String> stream = Stream.of("w", "o", "l", "f");
+		String word = stream.reduce("", (ss, c) -> ss + c);
+		System.out.println(word); // wolf
+
+		Stream<String> stream1 = Stream.of("w", "o", "l", "f");
+		String word1 = stream1.reduce("", String::concat);
+		System.out.println(word1);
+		/*
+		 * In many cases, the identity isn’t really necessary, so Java lets
+		 * us omit it. When you don’t specify an identity, an Optional is
+		 * returned because there might not be any data. There are three choices
+		 * for what is in the Optional
+		 * ■ If the stream is empty, an empty Optional is returned. 
+		 * ■ If the stream has one element, it is returned. 
+		 * ■ If the stream has multiple elements, the accumulator is
+		 * applied to combine them. 
+		 */
+		BinaryOperator<Integer> op = (a, b) -> a * b;
+		Stream<Integer> empty = Stream.empty();
+		Stream<Integer> oneElement = Stream.of(3);
+		Stream<Integer> threeElements = Stream.of(3, 5, 6);
+		empty.reduce(op).ifPresent(System.out::print); // no output
+		oneElement.reduce(op).ifPresent(System.out::print); // 3
+		threeElements.reduce(op).ifPresent(System.out::print); // 90
+		
+		// collect()
+		Stream<String> stream2 = Stream.of("w", "o", "l", "f");
+		StringBuilder word2 = stream2.collect(StringBuilder::new,
+		StringBuilder::append, StringBuilder::append);
+		System.out.println(word2);
+		
+		Stream<String> stream3 = Stream.of("w", "o", "l", "f");
+		TreeSet<String> set3 = stream3.collect(Collectors.toCollection(TreeSet::new));
+		System.out.println(set3); // [f, l, o, w]
+		
+		// unsorted
+		Stream<String> stream4 = Stream.of("w", "o", "l", "f");
+		Set<String> set = stream4.collect(Collectors.toSet());
+		System.out.println(set); // [f, w, l, o]
+	}
+
+	public static void main(String[] args) {
+		StreamCommonTerminalOperations s = new StreamCommonTerminalOperations();
+		s.test();
+	}
+}

Java-8/src/functionalProgramming/StreamSources.java

@@ -0,0 +1,28 @@
+package functionalProgramming;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * 
+ * @author chengfeili 
+ * Jun 8, 2017 9:37:58 PM
+ *
+ */
+public class StreamSources {
+
+	public void test() {
+		Stream<String> empty = Stream.empty(); // count = 0;
+		Stream<Integer> singleElement = Stream.of(1);
+		Stream<Integer> formArray = Stream.of(1, 2, 3);
+		// Java provides a convenient way to convert from a list to a stream
+		List<String> list = new ArrayList<>();
+		Stream<String> fromList = list.stream();
+		Stream<String> fromListParallel = list.parallelStream();
+
+		// infinite stream
+		Stream<Double> randoms = Stream.generate(Math::random);
+		Stream<Integer> oddNumbers = Stream.iterate(1, n -> n + 2);
+	}
+}