Crash Course on Lambda Expressions and Streams

@FunctionalInterface
public interface FooConsumer<T, U, S> {
    void accept(T t, U u, S s);
}

...
(a, b) -> { return a + b; }
(a, b) -> a + b;
...

...
(a, b) => { return a + b; }
(a, b) => a + b;
...

public void someMethod() {
    FooConsumer<String, String, String> foo = (a, b, c) -> {
        System.out.println(a + ", " + b + " and " + c);
    };

    // outputs "One, Two and Three"
    foo.accept("One", "Two", "Three");

    // outputs "Six, Nine and Ten"
    foo.accept("Six", "Nine", "Ten");
}

public void someOtherMethod() {
    BiFunction<Integer, Integer, String> foo = (a, b) -> {
        return "The product of " + a + " and " + b + " is " + (a * b);
    };

    String foo1 = foo.apply(5, 10);
    String foo2 = foo.apply(3, 5);

    // outputs "The product of 5 and 10 is 50"
    System.out.println(foo1);

    // outputs "The product of 3 and -5 is -15"
    System.out.println(foo2);
}

public void SomeMethod()
{
    Action<string, string, string> foo = (a, b, c) =>
    {
        Console.WriteLine(a + ", " + b + " and " + c);
    };

    // outputs "One, Two and Three"
    foo("One", "Two", "Three");

    // outputs "Six, Nine and Ten"
    foo("Six", "Nine", "Ten");
}

public void SomeOtherMethod() {
    Func<int, int, string> foo = (a, b) => {
        return "The product of " + a + " and " + b + " is " + (a * b);
    };

    string foo1 = foo(5, 10);
    string foo2 = foo(3, 5);

    // outputs "The product of 5 and 10 is 50"
    Console.WriteLine(foo1);

    // outputs "The product of 3 and -5 is -15"
    Console.WriteLine(foo2);
}

public void someLambdaMethodExecutor(BiFunction<Integer, Integer, Integer> fn) {
    System.out.println("Result of fn(1, 2) is " + fn.apply(1, 2));
}

public void someLambdaMethodCaller() {
    BiFunction<Integer, Integer, Integer> add = (a, b) -> {
        return a + b;
    };
    // this is also valid
    BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;

    // outputs "Result of fn(1, 2) is 3"
    someLambdaMethodExecutor(add);

    // outputs "Result of fn(1, 2) is 2"
    someLambdaMethodExecutor(multiply);
}

public void SomeLambdaMethodExecutor(Func<int, int, int> fn)
{
    Console.WriteLine("Result of fn(1, 2) is " + fn(1, 2));
}

public void SomeLambdaMethodCaller()
{
    Func<int, int, int> add = (a, b) => { return a + b; };
    // this is also valid
    Func<int, int, int> multiply = (a, b) => a * b;

    // outputs "Result of fn(1, 2) is 3"
    SomeLambdaMethodExecutor(add);

    // outputs "Result of fn(1, 2) is 2"
    SomeLambdaMethodExecutor(multiply);
}

public BiFunction<Integer, Integer, Integer> SomeLambdaGenerator(String which) {
    if ("add".equals(which))
        return (a, b) -> {  
            return a + b;
        };
    else
        return (a, b) -> {
            return a * b;
        };
}

public void SomeLambdaGeneratorCaller() {
    BiFunction<Integer, Integer, Integer> add = SomeLambdaGenerator("add");
    BiFunction<Integer, Integer, Integer> multiply = SomeLambdaGenerator("multiply");

    // outputs "1 + 2 = 3"
    System.out.println("1 + 2 = " + add.apply(1, 2));

    // outputs "1 * 2 = 2"
    System.out.println("1 * 2 = " + multiply.apply(1, 2));
}

public Func<int, int, int> SomeLambdaGenerator(string which)
{
    if (which == "add")
        return (a, b) => { return a + b; };
    else
        return (a, b) => { return a * b; };
}

public void SomeLambdaGeneratorCaller()
{
    Func<int, int, int> add = SomeLambdaGenerator("add");
    Func<int, int, int> multiply = SomeLambdaGenerator("multiply");

    // outputs "1 + 2 = 3"
    Console.WriteLine("1 + 2 = " + add(1, 2));

    // outputs "1 * 2 = 2"
    Console.WriteLine("1 * 2 = " + multiply(1, 2));
}

...
List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
Stream<Integer> numberStream = numbers.stream();
...

public void optionalExample() {
    Optional<String> someString = Optional.ofNullable("I'm here!");

    // the type can be inferred, so no need to specify it explicitly
    Optional<String> someAbsentString = Optional.ofNullable(null);

    // outputs "Some String: I'm Here!"
    someString.ifPresent(str -> System.out.println("Some String: " + str));

    // does nothing
    someAbsentString.ifPresent(str -> System.out.println("Some Absent String: " + str));

    // outputs "someAbsentString present? No"
    System.out.println("someAbsentString present? " + (someAbsentString.isPresent() ? "Yes" : "No"));

    // this throws an exception!
    // someAbsentString.get();
}

public void mapExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    List<Integer> mapped = numbers.stream().map(number -> number * 5).collect(Collectors.toList());

    // outputs "[5, 10, 15, 20, 25]"
    System.out.println(mapped);
}

public void MapExample()
{
    var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    var mapped = numbers.Select(number => number * 5).ToList();

    // outputs "5, 10, 15, 20, 25"
    Console.WriteLine(string.Join(", ", mapped));
}

public void flatMapExample() {
    Person john = new Person("John", Arrays.asList("John's Home", "John's Office"));
    Person mary = new Person("Mary", Arrays.asList("Mary's Home"));

    List<Person> people = new ArrayList<Person>(Arrays.asList(john, mary));

    // notice how the return type is incorrect
    List<List<String>> incorrect = people.stream().map(person -> person.getAddresses()).collect(Collectors.toList());

    // notice how the return of Person::getAddresses() is turned back into a stream
    List<String> allAddresses = people.stream().flatMap(person -> person.getAddresses().stream()).collect(Collectors.toList());

    // outputs "[[John's Home, John's Office], [Mary's Home]]" which is incorrect
    System.out.println(incorrect);

    // outputs "[John's Home, John's Office, Mary's Home]"
    System.out.println(allAddresses);
}

public void FlatMapExample()
{
    var john = new Person()
    {
        Name = "John",
        Addresses = new List<string>() { "John's Home", "John's Office" }
    };

    var mary = new Person()
    {
        Name = "Mary",
        Addresses = new List<string>() { "Mary's Home" }
    };

    var people = new List<Person>() { john, mary };

    // the type of this object is List<List<string>> which is obviously incorrect
    var incorrect = people.Select(person => person.Addresses).ToList();

    var allAddresses = people.SelectMany(person => person.Addresses).ToList();

    // outputs two lists which is incorrect, we want a list of all addresses
    Console.WriteLine(string.Join(", ", incorrect));

    // outputs "John's Home, John's Office, Mary's Home"
    Console.WriteLine(string.Join(", ", allAddresses));
}

public void filterExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    List<Integer> odds = numbers.stream().filter(number -> number % 2 == 1).collect(Collectors.toList());

    // outputs "[1, 3, 5]"
    System.out.println(odds);
}

public void FilterExample()
{
    var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    var odds = numbers.Where(number => number % 2 == 1).ToList();

    // outputs "1, 3, 5"
    Console.WriteLine(string.Join(", ", odds));
}

public void skipExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    List<Integer> remainder = numbers.stream().skip(3).collect(Collectors.toList());

    // outputs "[4, 5]"
    System.out.println(remainder);
}

public void SkipExample()
{
    var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    var remainder = numbers.Skip(3).ToList();

    // outputs "4, 5"
    Console.WriteLine(string.Join(", ", remainder));
}

public void limitExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    List<Integer> taken = numbers.stream().limit(3).collect(Collectors.toList());

    // outputs "[1, 2, 3]"
    System.out.println(taken);
}

public void TakeExample()
{
    var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    var taken = numbers.Take(3).ToList();

    // outputs "1, 2, 3"
    Console.WriteLine(string.Join(", ", taken));
}

public void distinctExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 1, 2, 3, 5));
    List<Integer> distinct = numbers.stream().distinct().collect(Collectors.toList());

    // outputs "[1, 2, 3, 5]"
    System.out.println(distinct);
}

public void DistinctExample()
{
    var numbers = new List<int>() { 1, 1, 2, 3, 5 };
    var distinct = numbers.Distinct().ToList();

    // outputs "1, 2, 3, 5"
    Console.WriteLine(string.Join(", ", distinct));
}

 public void sortExample() {
    Person john = new Person("John", Arrays.asList("John's Home", "John's Office"), 26);
    Person mary = new Person("Mary", Arrays.asList("Mary's Home"), 25);
    Person sean = new Person("Sean", Arrays.asList("Sean's Home"), 33);
    List<Person> people = new ArrayList<Person>(Arrays.asList(john, mary, sean));

    // this would fail since our Person class does not extend Comparable
    // List<Person> sorted = people.stream().sorted().collect(Collectors.toList());

    // this sorts people to their ages in a descending order
    // it works because we're explicitly specifying how one person relates to another in terms of order
    // also, if you wanted them in ascending order instead, simply reverse p1 and p2's ages in the subtraction
    List<Person> sorted = people.stream().sorted((p1, p2) -> p2.getAge() - p1.getAge()).collect(Collectors.toList());

    // outputs "[Sean (33), John (26), Mary (25)]"
    System.out.println(sorted);
}

public void SortExample()
{
    var john = new Person()
    {
        Name = "John",
        Addresses = new List<string>() { "John's Home", "John's Office" },
        Age = 26
    };

    var mary = new Person()
    {
        Name = "Mary",
        Addresses = new List<string>() { "Mary's Home" },
        Age = 25
    };

    var sean = new Person()
    {
        Name = "Sean",
        Addresses = new List<string>() { "Sean's Home" },
        Age = 33
    };

    var people = new List<Person>() { john, mary, sean };

    // sorts people to their ages in a descending order
    var sorted = people.OrderByDescending(x => x.Age).ToList();

    // outputs "Sean (33), John (26), Mary (25)"
    Console.WriteLine(string.Join(", ", sorted));
}

    public void reduceExample() {
    List<Integer> numbers = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    int sum = numbers.stream().reduce(50, (a, b) -> a + b);

    // we can emulate collect(Collectors.toList()) using the reduce operation!
    // this overload of the method reduce() accepts three parameters: initial value, accumulator and combiner
    // the accumulator function accumulates an item from the stream into the current accumulation
    // and the combiner function is used to combine two accumulations in case they run in parallel
    // so it's safe to say that the combiner function is a fail-safe mechanism for concurrency cases
    List<Integer> asList = numbers.stream().reduce(new ArrayList<Integer>(), (list, number) -> {
        list.add(number);
        return list;
    }, (list1, list2) -> {
        list1.addAll(list2);
        return list1;
    });

    // outputs "65"
    System.out.println(sum);

    // outputs "[1, 2, 3, 4, 5]"
    System.out.println(asList);
}

public void ReduceExample()
{
    var numbers = new List<int>() { 1, 2, 3, 4, 5 };
    var sum = numbers.Aggregate(50, (a, b) => a + b);

    // we can emulate IEnumerable.ToList() using the reduce operation!
    var asList = numbers.Aggregate(new List<int>(), (list, number) =>
    {
        list.Add(number);
        return list;
    });

    // outputs "65"
    Console.WriteLine(sum);

    // outputs "1, 2, 3, 4, 5"
    Console.WriteLine(string.Join(", ", asList));
}