Lecture 20: Generics, Interfaces, Lambdas

Checker.java

package transform;

public interface Checker<T> {

    boolean check(T value);
}

Main.java

package transform;

import java.util.List;

public class Main {

    public static void main(String[] args) {
        List<Integer> numbers = List.of(11, 33, 45, -9, 0, 135);
        System.out.println("Original");
        System.out.println(numbers);
        System.out.println("============");
        System.out.println(Utils.multiplyByTwo(numbers));
        System.out.println(Utils.addTen(numbers));
        System.out.println(Utils.onlyNegatives(numbers));


        //The following two statements are equivalent
        System.out.println(Utils.filterList(numbers, x -> {
            int remainder = x % 2;
            return remainder != 0;
        }));
        System.out.println(Utils.filterList(numbers, x -> (x % 2) != 0));



        System.out.println("============");

        List<String> strings = List.of("каждый", "охотник", "желает", "знать", "где", "сидит", "фазан");
        System.out.println("Originals");
        System.out.println("---------");
        System.out.println(Utils.firstLetters(strings));
        System.out.println(Utils.filterList(strings, x -> x.length() == 5));




        //[ к, а, ж, д, ы, й, о, х, о, т, н, и, к.....]
        //[2, 4, 6, 1] => [ 1, 2, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6, 1]

    }
}

Transformer.java

package transform;

public interface Transformer<T> {
    T transformOriginal(T original);
}
/*
public interface Transformer {
  Integer transformOriginal(Integer original);
}
 */

Utils.java

package transform;

import java.util.ArrayList;
import java.util.List;

public class Utils {

    public static List<Integer> multiplyByTwo(List<Integer> source) {
//        Transformer<Integer> timesTwo = new Transformer<Integer>() {
//            @Override
//            public Integer transformOriginal(Integer original) {
//                return original * 2;
//            }
//        };
        Transformer<Integer> timesTwo = (Integer original) -> original * 2;

        return transformList(source, timesTwo);
    }

    public static List<Integer> addTen(List<Integer> source) {
        class PlusTenTransformer implements Transformer<Integer> {
//        Transformer<Integer> plusTen = new Transformer<Integer>() {

            @Override
            public Integer transformOriginal(Integer original) {
                return original + 10;
            }
        };

        PlusTenTransformer plusTen = new PlusTenTransformer();

        return transformList(source, plusTen);
    }

    public static List<String> firstLetters(List<String> source) {
        Transformer<String> getFirstLetter = new Transformer<String>() {
            @Override
            public String transformOriginal(String original) {
                return String.valueOf(original.charAt(0));
            }
        };

        return transformList(source, getFirstLetter);
    }


    public static List<Integer> onlyNegatives(List<Integer> source) {
//        Checker<Integer> checker = new Checker<Integer>() {
//            @Override
//            public boolean check(Integer value) {
//                return value < 0;
//            }
//        };
        return filterList(source, x -> x < 0);
    }

    public static <T> List<T> transformList(List<T> source, Transformer<T> transformer) {
        List<T> result = new ArrayList<>();
        for (T currentElement : source) {
            T elementAfterTransformation = transformer.transformOriginal(currentElement);
            result.add(elementAfterTransformation);
        }
        return result;
    }

    public static <T> List<T> filterList(List<T> source, Checker<T> checker) {
        List<T> result = new ArrayList<>();
        for (T currentElement : source) {
            if (checker.check(currentElement)) {
                result.add(currentElement);
            }
        }
        return result;
    }
}