java.util.function

---

1. Predicate to check if a string is empty:

Predicate<String> isEmpty = String::isEmpty;

1. Function to get the length of a string:

Function<String, Integer> length = String::length;

1. Consumer to print a string:

Consumer<String> print = System.out::println;

1. Supplier to generate a random number:

Supplier<Integer> randomNumber = () -> (int) (Math.random() * 10);

1. BiFunction to calculate the area of a rectangle:

BiFunction<Integer, Integer, Integer> area = (width, height) -> width * height;

1. UnaryOperator to increment a number:

UnaryOperator<Integer> increment = x -> x + 1;

1. BinaryOperator to add two numbers:

BinaryOperator<Integer> add = (x, y) -> x + y;

1. Comparator to compare two strings:

Comparator<String> comparator = Comparator.comparing(String::length);

1. Runnable to create a thread that prints a message:

Runnable runnable = () -> System.out.println("Hello, world!");

1. BiConsumer to accept two strings and print them:

BiConsumer<String, String> printPair = (x, y) -> System.out.println(x + ", " + y);

1. ToIntFunction to convert a string to an integer:

ToIntFunction<String> toInt = Integer::parseInt;

1. ToDoubleFunction to convert a string to a double:

ToDoubleFunction<String> toDouble = Double::parseDouble;

1. ToLongFunction to convert a string to a long:

ToLongFunction<String> toLong = Long::parseLong;

1. IntPredicate to check if an integer is even:

IntPredicate isEven = x -> x % 2 == 0;

1. DoublePredicate to check if a double is greater than 0:

DoublePredicate isPositive = x -> x > 0;

1. LongPredicate to check if a long is less than 10:

LongPredicate isLessThan10 = x -> x < 10;

1. Consumer to print a formatted string:

Consumer<String> printFormatted = System.out::printf;

1. BiFunction to create a pair:

BiFunction<Integer, Integer, Pair<Integer, Integer>> createPair = Pair::of;

1. BinaryOperator to combine two pairs:

BinaryOperator<Pair<Integer, Integer>> combinePairs = (x, y) -> Pair.of(x.getKey() + y.getKey(), x.getValue() + y.getValue());

1. Supplier to generate a list of numbers:

Supplier<List<Integer>> generateNumbers = () -> Stream.iterate(1, x -> x + 1).limit(10).toList();

1. Comparator to compare two lists:

Comparator<List<Integer>> comparator = Comparator.comparingInt(List::size);

1. Consumer to print a list of numbers:

Consumer<List<Integer>> printNumbers = System.out::println;

1. BiFunction to calculate the sum of two lists:

BiFunction<List<Integer>, List<Integer>, List<Integer>> sumLists = (x, y) -> {
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < x.size(); i++) {
        result.add(x.get(i) + y.get(i));
    }
    return result;
};

1. UnaryOperator to square a number:

UnaryOperator<Integer> square = x -> x * x;

1. BinaryOperator to multiply two numbers:

BinaryOperator<Integer> multiply = (x, y) -> x * y;

1. Comparator to compare two numbers by their absolute value:

Comparator<Integer> comparator = Comparator.comparingInt(Math::abs);

1. Supplier to generate a random boolean:

Supplier<Boolean> randomBoolean = () -> Math.random() < 0.5;

1. Consumer to print a boolean:

Consumer<Boolean> printBoolean = System.out::println;

1. BiConsumer to accept two booleans and print them:

BiConsumer<Boolean, Boolean> printBooleanPair = (x, y) -> System.out.println(x + ", " + y);

1. ToIntFunction to convert a boolean to an integer:

ToIntFunction<Boolean> toInt = x -> x ? 1 : 0;

1. ToDoubleFunction to convert a boolean to a double:

ToDoubleFunction<Boolean> toDouble = x -> x ? 1.0 : 0.0;

1. ToLongFunction to convert a boolean to a long:

ToLongFunction<Boolean> toLong = x -> x ? 1L : 0L;

1. IntPredicate to check if an integer is divisible by 3:

IntPredicate isDivisibleBy3 = x -> x % 3 == 0;

1. DoublePredicate to check if a double is negative:

DoublePredicate isNegative = x -> x < 0;

1. LongPredicate to check if a long is positive:

LongPredicate isPositive = x -> x > 0;

1. Consumer to print an object:

Consumer<Object> printObject = System.out::println;

1. BiConsumer to accept two objects and print them:

BiConsumer<Object, Object> printObjectPair = (x, y) -> System.out.println(x + ", " + y);

1. Supplier to generate a list of objects:

Supplier<List<Object>> generateObjects = () -> Stream.iterate(1, x -> x + 1).limit(10).map(Object::new).toList();

1. Comparator to compare two objects by their class name:

Comparator<Object> comparator = Comparator.comparing(Object::getClass.getName);

1. Predicate to check if an object is an instance of a particular class:

Predicate<Object> isInstance = o -> o instanceof String;

1. Function to get the class of an object:

Function<Object, Class<?>> getClass = Object::getClass;

1. Consumer to print the class of an object:

Consumer<Object> printClass = System.out::println;

1. BiConsumer to accept two objects and print their classes:

BiConsumer<Object, Object> printClassPair = (x, y) -> System.out.println(x.getClass().getName() + ", " + y.getClass().getName());

1. Supplier to generate a random object:

Supplier<Object> randomObject = () -> {
    int randomNumber = (int) (Math.random() * 3);
    switch (randomNumber) {
        case 0:
            return new String();
        case 1:
            return new Integer();
        case 2:
            return new Double();
        default:
            throw new RuntimeException("Invalid random number");
    }
};

1. Comparator to compare two objects by their hash code:

Comparator<Object> comparator = Comparator.comparingInt(Object::hashCode);

1. Predicate to check if an object is null:

Predicate<Object> isNull = Objects::isNull;

1. Function to get the string representation of an object:

Function<Object, String> toString = Object::toString;

1. Consumer to print the string representation of an object:

Consumer<Object> printToString = System.out::println;

1. BiConsumer to accept two objects and print their string representations:

BiConsumer<Object, Object> printToStringPair = (x, y) -> System.out.println(x.toString() + ", " + y.toString());

1. Supplier to generate a random list of objects:

Supplier<List<Object>> generateObjects = () -> Stream.iterate(1, x -> x + 1).limit(10).map(x -> {
    int randomNumber = (int) (Math.random() * 3);
    switch (randomNumber) {
        case 0:
            return new String();
        case 1:
            return new Integer();
        case 2:
            return new Double();
        default:
            throw new RuntimeException("Invalid random number");
    }
}).toList();