@Override
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
    return false;
}

import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class MyCache<K, V> extends LinkedHashMap<K, V> {

    private final int limitSize;

    public MyCache(int limitSize) {
        this.limitSize = limitSize;
    }

    @Override
    protected boolean removeEldestEntry(Entry<K, V> eldest) {
        return size() > this.limitSize;
    }
}

public class Main {

    public static void main(String[] args) {
        MyCache<String, Integer> cache = new MyCache<>(3);
        cache.put("1", 1);
        cache.put("2", 2);
        cache.put("3", 3);
        cache.put("4", 4);
        System.out.println(String.join(", ", cache.keySet()));
    }
}

import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class MyCache2<K, V> extends LinkedHashMap<K, V> {
    private final EldestEntryRemovalFunction<K, V> eldestEntryRemovalFunction;

    public MyCache2(EldestEntryRemovalFunction<K, V> eldestEntryRemovalFunction) {
        this.eldestEntryRemovalFunction = eldestEntryRemovalFunction;
    }

    @Override
    protected boolean removeEldestEntry(Entry<K, V> eldest) {
        return eldestEntryRemovalFunction.remove(this, eldest);
    }
}

import java.util.Map;

public interface EldestEntryRemovalFunction<K, V> {
    boolean remove(Map<K, V> map, Map.Entry<K, V> eldest);
}

MyCache2<String, Integer> cache2 = new MyCache2<>(((map, eldest) -> map.size() > 3));
// 이하 동일

public class MyCache3<K, V> extends LinkedHashMap<K, V> {

  private final BiPredicate<Map<K, V>, Map.Entry<K, V>> biPredicate;

  public Cache(BiPredicate<Map<K, V>, Map.Entry<K, V>> biPredicate) {
    this.biPredicate = biPredicate;
  }

  @Override
  protected boolean removeEldestEntry(Entry<K, V> eldest) {
    return biPredicate.test(this, eldest);
  }
}
// 나머지 동일

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    /**
     * Returns a unary operator that always returns its input argument.
     *
     * @param <T> the type of the input and output of the operator
     * @return a unary operator that always returns its input argument
     */
    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

String::toLowerCase

package java.util.function;

import java.util.Objects;
import java.util.Comparator;

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {
    /**
     * Returns a {@link BinaryOperator} which returns the lesser of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the lesser of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    /**
     * Returns a {@link BinaryOperator} which returns the greater of two elements
     * according to the specified {@code Comparator}.
     *
     * @param <T> the type of the input arguments of the comparator
     * @param comparator a {@code Comparator} for comparing the two values
     * @return a {@code BinaryOperator} which returns the greater of its operands,
     *         according to the supplied {@code Comparator}
     * @throws NullPointerException if the argument is null
     */
    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    // 다른 메서드 ...
}

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

@FunctionalInterface
public interface Comparator<T> {
  int compare(T o1, T o2);
  //이하 생략
}

public interface ExecutorService extends Executor {
  // ...
  
  <T> Future<T> submit(Callable<T> task);
  Future<?> submit(Runnable task);

  // ...
}