제네릭 filter와 map 직접 만들기

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

public final class ConcreteCollectionUtilities {
    static List<String> longStrings(List<String> source) {
        List<String> result = new ArrayList<>();
        for (String value : source) {
            if (value.length() >= 5) {
                result.add(value);
            }
        }
        return result;
    }

    static List<Integer> squares(List<Integer> source) {
        List<Integer> result = new ArrayList<>();
        for (Integer value : source) {
            result.add(value * value);
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(longStrings(List.of("map", "filter", "lambda", "for")));
        System.out.println(squares(List.of(1, 2, 3, 4)));
    }
}

[filter, lambda]
[1, 4, 9, 16]

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public final class StrictFilterMap {
    static <T> List<T> filter(List<T> source, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T value : source) {
            if (predicate.test(value)) {
                result.add(value);
            }
        }
        return result;
    }

    static <T, R> List<R> map(List<T> source, Function<T, R> mapper) {
        List<R> result = new ArrayList<>();
        for (T value : source) {
            result.add(mapper.apply(value));
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(filter(List.of("map", "filter", "lambda", "for"), value -> value.length() >= 5));
        System.out.println(map(List.of(1, 2, 3, 4), value -> value * value));
    }
}

[filter, lambda]
[1, 4, 9, 16]

        List<Integer> scores = List.of(70, -5, 90);
        Predicate<Number> positive = number -> number.doubleValue() > 0;
        List<Integer> valid = filter(scores, positive);

        List<String> words = List.of("map", "filter");
        Function<String, Integer> length = String::length;
        List<Number> lengths = map(words, length);

StrictFilterMap.java:31: error: method filter in class StrictFilterMap cannot be applied to given types;
        List<Integer> valid = filter(scores, positive);
                              ^
  required: List<T>,Predicate<T>
  found:    List<Integer>,Predicate<Number>
  reason: inference variable T has incompatible equality constraints Number,Integer
  where T is a type-variable:
    T extends Object declared in method <T>filter(List<T>,Predicate<T>)
StrictFilterMap.java:35: error: incompatible types: inference variable R has incompatible equality constraints Number,Integer
        List<Number> lengths = map(words, length);
                                  ^
  where R,T are type-variables:
    R extends Object declared in method <T,R>map(List<T>,Function<T,R>)
    T extends Object declared in method <T,R>map(List<T>,Function<T,R>)
2 errors

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public final class GenericFilterMap {
    static <T> List<T> filter(List<? extends T> source, Predicate<? super T> predicate) {
        List<T> result = new ArrayList<>();
        for (T value : source) {
            if (predicate.test(value)) {
                result.add(value);
            }
        }
        return List.copyOf(result);
    }

    static <T, R> List<R> map(
            List<? extends T> source,
            Function<? super T, ? extends R> mapper) {
        List<R> result = new ArrayList<>(source.size());
        for (T value : source) {
            result.add(mapper.apply(value));
        }
        return List.copyOf(result);
    }

    record Product(String name, int price) {
    }

    public static void main(String[] args) {
        List<Product> products = List.of(
                new Product("Keyboard", 120),
                new Product("Cable", 15),
                new Product("Book", 35));
        List<Product> affordable = filter(products, product -> product.price() <= 50);
        List<String> names = map(affordable, Product::name);
        List<Integer> nameLengths = map(names, String::length);
        System.out.println(affordable);
        System.out.println(names);
        System.out.println(nameLengths);

        List<Integer> scores = List.of(70, -5, 90);
        Predicate<Number> positive = number -> number.doubleValue() > 0;
        List<Integer> valid = filter(scores, positive);

        List<String> words = List.of("map", "filter");
        Function<String, Integer> length = String::length;
        List<Number> lengths = map(words, length);
        System.out.println(valid);
        System.out.println(lengths);
    }
}

[Product[name=Cable, price=15], Product[name=Book, price=35]]
[Cable, Book]
[5, 4]
[70, 90]
[3, 6]

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public final class FilterMapTrace {
    static <T> List<T> filter(List<? extends T> source, Predicate<? super T> predicate) {
        List<T> result = new ArrayList<>();
        for (T value : source) {
            if (predicate.test(value)) {
                result.add(value);
            }
        }
        return List.copyOf(result);
    }

    static <T, R> List<R> map(
            List<? extends T> source,
            Function<? super T, ? extends R> mapper) {
        List<R> result = new ArrayList<>(source.size());
        for (T value : source) {
            result.add(mapper.apply(value));
        }
        return List.copyOf(result);
    }

    public static void main(String[] args) {
        List<Integer> source = new ArrayList<>(List.of(3, 1, 4, 2));
        List<String> trace = new ArrayList<>();
        List<Integer> selected = filter(source, value -> {
            trace.add("test:" + value);
            return value % 2 == 0;
        });
        List<String> mapped = map(selected, value -> {
            trace.add("map:" + value);
            return "N" + value;
        });
        System.out.println("source=" + source);
        System.out.println("selected=" + selected);
        System.out.println("mapped=" + mapped);
        System.out.println("trace=" + trace);

        source.add(6);
        System.out.println("after source.add(6): selected=" + selected);
        try {
            selected.add(8);
        } catch (UnsupportedOperationException exception) {
            System.out.println("selected.add(8): " + exception.getClass().getSimpleName());
        }
    }
}

source=[3, 1, 4, 2]
selected=[4, 2]
mapped=[N4, N2]
trace=[test:3, test:1, test:4, test:2, map:4, map:2]
after source.add(6): selected=[4, 2]
selected.add(8): UnsupportedOperationException

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public final class MapFailurePoint {
    static <T, R> List<R> map(
            List<? extends T> source,
            Function<? super T, ? extends R> mapper) {
        List<R> result = new ArrayList<>(source.size());
        for (T value : source) {
            result.add(mapper.apply(value));
        }
        return List.copyOf(result);
    }

    public static void main(String[] args) {
        List<String> inputs = List.of("ok", "bad", "later");
        List<String> trace = new ArrayList<>();

        try {
            map(inputs, value -> {
                trace.add("map:" + value);
                return value.equals("bad") ? null : value.toUpperCase();
            });
        } catch (NullPointerException exception) {
            System.out.println("returns null -> NullPointerException " + trace);
        }

        trace.clear();
        try {
            map(inputs, value -> {
                trace.add("map:" + value);
                if (value.equals("bad")) {
                    throw new IllegalArgumentException("bad input");
                }
                return value.toUpperCase();
            });
        } catch (IllegalArgumentException exception) {
            System.out.println("throws -> IllegalArgumentException " + trace);
        }
    }
}

returns null -> NullPointerException [map:ok, map:bad, map:later]
throws -> IllegalArgumentException [map:ok, map:bad]

Predicate<Object> notNull = Objects::nonNull;
List<String> kept = filter(words, notNull);                 // (가)

Function<CharSequence, Integer> size = CharSequence::length;
List<Integer> sizes = map(words, size);                     // (나)

Predicate<Integer> even = value -> value % 2 == 0;
List<Number> evens = filter(numbers, even);                 // (다)

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

public final class IndexedMapSolution {
    @FunctionalInterface
    interface IndexedMapper<T, R> {
        R map(int index, T value);
    }

    static <T, R> List<R> mapIndexed(
            List<? extends T> source,
            IndexedMapper<? super T, ? extends R> mapper) {
        List<R> result = new ArrayList<>(source.size());
        int index = 0;
        for (T value : source) {
            R mapped = mapper.map(index, value);
            result.add(Objects.requireNonNull(mapped, "null result at index " + index));
            index += 1;
        }
        return List.copyOf(result);
    }

    public static void main(String[] args) {
        List<String> result = mapIndexed(
                List.of("java", "lambda", "stream"),
                (index, value) -> index + ":" + value);
        System.out.println(result);
        try {
            mapIndexed(List.of("ok", "bad"), (index, value) -> index == 1 ? null : value);
        } catch (NullPointerException exception) {
            System.out.println(exception.getMessage());
        }
    }
}

[0:java, 1:lambda, 2:stream]
null result at index 1

  reason: inference variable T has incompatible bounds
    upper bounds: Integer,Object
    lower bounds: Number