Функциональные интерфейсы

Все темы Java Developer

Что такое функциональные интерфейсы?

Функциональный интерфейс задаёт единственный функциональный контракт абстрактного метода. Аннотация @FunctionalInterface необязательна и ставится на интерфейсе, а не на методе. Default- и static-методы не мешают; методы, совпадающие с public-методами Object, не учитываются при определении функционального контракта.

1. Один абстрактный метод: Функциональный интерфейс может содержать только один абстрактный метод, но может также содержать любое количество методов по умолчанию (default methods) или статических методов.

2. Аннотация @FunctionalInterface: Для обозначения функционального интерфейса используется аннотация @FunctionalInterface. Это помогает компилятору проверить, что интерфейс соответствует требованиям функционального интерфейса (имеет только один абстрактный метод).

Примеры стандартных функциональных интерфейсов, включенных в стандартную библиотеку Java (package java.util.function):

• Supplier<T>: поставщик (не принимает аргументов, возвращает значение типа T).

• Consumer<T>: потребитель (принимает аргумент типа T, не возвращает значения).

• Predicate<T>: предикат (принимает аргумент типа T, возвращает boolean).

• Function<T, R>: функция (принимает аргумент типа T, возвращает значение типа R).

@FunctionalInterface
interface MyFunction {
    void myMethod(String arg);
}

public class Main {
    public static void main(String[] args) {
        // Использование лямбда-выражения для реализации функционального интерфейса
        MyFunction func = (arg) -> System.out.println("Hello, " + arg);
        func.myMethod("world");
    }
}

Для чего нужен функциональный интерфейс BiConsumer<T,U>?

Функциональный интерфейс BiConsumer<T, U> в Java представляет собой интерфейс, который определяет операцию, принимающую два входных аргумента (типов T и U) и не возвращающую результат (void). Он используется для передачи операций, которые принимают два аргумента и выполняют какие-то действия с ними, например, их выводят на экран, сохраняют в базу данных или выполняют любую другую операцию.

1. Параметризация типами T и U: Эти типы могут быть любыми объектными типами данных, например, Integer, String , Object и т.д.

2. Нет возвращаемого значения: Метод accept(T t, U u) интерфейса BiConsumer ничего не возвращает (void).

3. Пример использования:

   import java.util.function.BiConsumer;
   
   public class Main {
       public static void main(String[] args) {
           BiConsumer<String, Integer> printLength = (str, num) ->
               System.out.println("Length of '" + str + "' is " + num);
   
           printLength.accept("Java", 4);
           printLength.accept("OpenAI", 6);
       }
   }

   Здесь printLength — это экземпляр функционального интерфейса BiConsumer, который принимает строку и целое число (длину строки) и выводит информацию о длине строки на экран.

4. Использование в потоковых операциях: BiConsumer может использоваться в потоковых операциях для выполнения параллельных действий над парами данных.

BiConsumer<T, U> полезен в случаях, когда требуется выполнить операции, которые работают с двумя аргументами, не возвращая результат. Это удобно для реализации методов обратного вызова, для обработки данных в парах или для выполнения действий над двумя различными аргументами одновременно.

Для чего нужен функциональный интерфейс BiFunction<T,U,R>?

Функциональный интерфейс BiFunction<T, U, R> в Java представляет собой интерфейс, который определяет функцию, принимающую два входных аргумента (типов T и U) и возвращающую результат (типа R). Он используется для передачи операций, которые принимают два аргумента и возвращают какое-то значение на основе этих аргументов.

1. Параметризация типами T, U и R: Эти типы могут быть любыми объектными типами данных, например, Integer, String, Object и т.д. R обозначает тип возвращаемого значения.

2. Метод apply: Интерфейс BiFunction содержит абстрактный метод R apply(T t, U u), который принимает два аргумента типов T и U и возвращает значение типа R.

3. Пример использования:

   import java.util.function.BiFunction;
   
   public class Main {
       public static void main(String[] args) {
           BiFunction<String, Integer, String> repeat = (str, count) -> {
               StringBuilder result = new StringBuilder();
               for (int i = 0; i < count; i++) {
                   result.append(str);
               }
               return result.toString();
           };
   
           String repeated = repeat.apply("Hello", 3);
           System.out.println(repeated);  // Выведет: HelloHelloHello
       }
   }

   Здесь repeat — это экземпляр функционального интерфейса BiFunction, который принимает строку (String) и целое число (Integer) и возвращает строку (String), повторяющуюся заданное количество раз.

4. Использование в потоковых операциях: BiFunction может использоваться в потоковых операциях для преобразования или комбинирования данных, которые требуют двух входных аргументов.

BiFunction<T, U, R> полезен в случаях, когда нужно выполнить операции, зависящие от двух аргументов, и вернуть какой-то результат. Он обеспечивает гибкость и возможность создавать функции, способные работать с двумя различными типами данных и возвращать результат, соответствующий задаче.

Для чего нужен функциональный интерфейс BiPredicate<T,U>?

Функциональный интерфейс BiPredicate<T, U> в Java представляет собой интерфейс, который определяет предикат — операцию, принимающую два входных аргумента (типов T и U) и возвращающую булево значение (boolean). Он используется для передачи операций, которые проверяют условие на основе двух аргументов и возвращают true или false.

1. Параметризация типами T и U: Эти типы могут быть любыми объектными типами данных, например, Integer, String , Object и т.д.

2. Метод test: Интерфейс BiPredicate содержит абстрактный метод boolean test(T t, U u), который принимает два аргумента типов T и U и возвращает булево значение (true или false).

3. Пример использования:

   import java.util.function.BiPredicate;
   
   public class Main {
       public static void main(String[] args) {
           BiPredicate<String, Integer> isLengthGreaterThan = (str, length) -> str.length() > length;
   
           boolean result1 = isLengthGreaterThan.test("Java", 3);
           System.out.println("Is 'Java' longer than 3? " + result1);  // Выведет: true
   
           boolean result2 = isLengthGreaterThan.test("Python", 6);
           System.out.println("Is 'Python' longer than 6? " + result2);  // Выведет: false
       }
   }

   Здесь isLengthGreaterThan — это экземпляр функционального интерфейса BiPredicate, который проверяет длину строки (String) и возвращает true, если длина больше указанного числа.

4. Использование в потоковых операциях: BiPredicate может использоваться в потоковых операциях для фильтрации данных, зависящей от двух входных аргументов.

BiPredicate<T, U> полезен в ситуациях, когда требуется проверять условия, зависящие от двух различных типов данных, и возвращать результат в виде булевого значения. Он обеспечивает гибкость и возможность создавать функции для сложных логических проверок, которые требуют двух аргументов.

Для чего нужны функциональные интерфейсы вида _To_Function?

Функциональные интерфейсы вида _To_Function в Java представляют собой группу интерфейсов, которые принимают один тип данных и возвращают другой тип данных. Они используются для передачи операций, которые преобразуют входные данные одного типа в выходные данные другого типа.

1. Преобразование данных: Интерфейсы, такие как Function<T, R>, ToIntFunction<T>, ToDoubleFunction<T>, ToLongFunction<T>, LongToDoubleFunction, и другие, используются для преобразования данных из одного типа в другой.

2. Потоковые операции: В Java 8 и более поздних версиях многие из этих интерфейсов широко используются в потоковых операциях (Stream API) для выполнения преобразований данных или извлечения нужных значений из объектов.

3. Функции обратного вызова (Callback functions): Они часто используются как функции обратного вызова, когда требуется выполнить определенные операции над данными и вернуть результат.

Вот некоторые примеры функциональных интерфейсов вида _To_Function и их основные задачи:

• Function<T, R>: Принимает аргумент типа T и возвращает результат типа R.

• ToIntFunction<T>, ToDoubleFunction<T>, ToLongFunction<T>: Принимают аргумент типа T и возвращают примитивные значения int, double, long соответственно.

• LongToDoubleFunction, IntToDoubleFunction: Принимают примитивные значения long или int и возвращают значение double.

• DoubleToIntFunction, DoubleToLongFunction: Принимают значение double и возвращают примитивные значения int или long.