⌨️ Поддержка лямбда выражений в своём коде

В Java лямбда-выражения используются с функциональными интерфейсами, которые имеют ровно один абстрактный метод. Например, стандартный функциональный интерфейс Function из пакета java.util.function представляет собой типичный пример.

Для нашего примера используем встроенный функциональный интерфейс IntUnaryOperator. Он выглядит вот так:

@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}

Этот интерфейс представляет функцию, которая принимает один аргумент типа int и возвращает значение типа int.

import java.util.function.IntUnaryOperator;

public class Main {
    public static int applyOperation(int number, IntUnaryOperator operator) {
        return operator.applyAsInt(number);
    }

    public static void main(String[] args) {
        int number = 5;

        // Лямбда-выражение для удвоения значения
        IntUnaryOperator doubleOperation = x -> x * 2;
        System.out.println("Double: " + applyOperation(number, doubleOperation)); // Double: 10

        // Лямбда-выражение для увеличения значения на 10
        IntUnaryOperator addTenOperation = x -> x + 10;
        System.out.println("Add Ten: " + applyOperation(number, addTenOperation)); // Add Ten: 15
    }
}

В нашем примере метод applyOperation принимает два параметра: число и функциональный интерфейс IntUnaryOperator. Лямбда-выражение используется для определения конкретной функции.

#java #lambda #IntUnaryOperator

⌨️ Лямбда-выражения и свой кастомный функциональный интерфейс

Для того что бы определить лямбда-выражение, нам нужен функциональный интерфейс. Изобретём свой:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Функциональный интерфейс MathOperation содержит один абстрактный метод operate, который принимает два значения типа int и возвращает int. Аннотация @FunctionalInterface указывает на то, что интерфейс предназначен для использования в функциональном программировании и должен содержать только один абстрактный метод. Но аннотация не обязательна.

Использование лямбда-выражения:

public class LambdaExample {
    public static void main(String[] args) {
        // Реализация интерфейса с помощью лямбда-выражения
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;
        MathOperation multiplication = (a, b) -> a * b;
        MathOperation division = (a, b) -> a / b;

        int x = 10;
        int y = 5;

        System.out.println("Addition: " + operate(x, y, addition)); // 15
        System.out.println("Subtraction: " + operate(x, y, subtraction)); // 5
        System.out.println("Multiplication: " + operate(x, y, multiplication)); // 50
        System.out.println("Division: " + operate(x, y, division)); // 2
    }

    // Метод, принимающий MathOperation и применяющий его к данным
    private static int operate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }
}

В нашем примере лямбда-выражения используются для создания экземпляров интерфейса MathOperation для выполнения различных математических операций (сложение, вычитание и т.д.).

Метод operate принимает два целых числа и функциональный интерфейс MathOperation, затем выполняет переданную операцию. В метод в третьем параметре можно передать непосредственно лямбда-выражение, не используя промежуточную переменную.

#java #lambda #FunctionalInterface

⌨️ Суть лямбда-выражений

Лямбда-выражения на первый взгляд могут показаться чем-то сложным и загадочным, но на самом деле они просты и интуитивно понятны.

Лямбда-выражение — это лаконичный способ описания анонимной функции, которую можно передать в качестве параметра или сохранить в переменной для последующего использования.

Если говорить ещё проще, лямбда-выражение — это просто другой способ создания и реализации объекта определённого типа. Рассмотрим это на примере создания нового потока.

У класса Thread есть конструктор:

public Thread(Runnable target) {
    ...
}

То есть в конструктор нужно передать объект типа Runnable. До лямбда-выражений мы сделали бы так:

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}).start();

Здесь мы создаём анонимный класс, реализующий интерфейс Runnable, с определённым методом run.
Если использовать лямбда-выражение, тот же код будет выглядеть следующим образом:

Runnable r = () -> System.out.println("Hello World");
new Thread(r).start();

Или проще:

new Thread(() -> System.out.println("Hello World")).start();

Лямбда-выражение заменяет собой анонимный класс, который раньше был бы необходим для реализации Runnable. Лямбда-выражение может использоваться только там, где ожидается реализация функционального интерфейса — интерфейса с единственным абстрактным методом.
А интерфейс Runnable именно такой:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Функциональный интерфейс должен содержать только один абстрактный метод, чтобы компилятор мог точно определить, какой метод реализует лямбда-выражение. В противном случае возникли бы неоднозначности и ошибки.

#java #lambda #Runnable

⌨️ Lambda-выражения

Лямбда-выражения появились в Java 8 и предоставили простой способ описывать анонимные функции, что позволяет писать более лаконичный и читабельный код. Лямбды активно используются при работе с коллекциями, потоками данных и функциональными интерфейсами.

Раньше для создания анонимного класса нужно было писать много кода:

List<String> names = Arrays.asList("John", "Alice", "Bob");
names.forEach(new Consumer<String>() {
    @Override
    public void accept(String name) {
        System.out.println(name);
    }
});

С лямбда-выражениями:

List<String> names = Arrays.asList("John", "Alice", "Bob");
names.forEach(name -> System.out.println(name));

Лямбды позволяют сократить код и сделать его более читабельным, особенно когда нужно передавать поведение как параметр (например, для фильтрации, сортировки и других операций).

#java #lambda

⌨️ Захват переменных в лямбда-выражениях

Лямбда-выражения могут захватывать переменные из внешнего окружения, делая их доступными внутри лямбда-функции. При этом переменные могут быть:

1️⃣ Неизменяемыми (effectively final) – Переменная из внешнего контекста, используемая в лямбде, должна быть объявлена как final или фактически быть неизменяемой (то есть не изменяться после первого присваивания). Например:

int x = 10;
Runnable r = () -> System.out.println(x);  // x захвачен в лямбде

2️⃣ Свободными от изменения в лямбде – Лямбда не может изменять захваченные переменные. Это ограничение гарантирует, что нет неоднозначного состояния, когда переменная изменяется из нескольких мест (например, из основного потока и из лямбда-функции одновременно).

3️⃣ Статическими или полями класса – В отличие от локальных переменных, статические поля класса или поля экземпляра могут свободно изменяться внутри лямбда-выражений, поскольку их значения хранятся в куче (heap) и доступны по ссылке.

Пример:

public class Main {
    private static int staticVar = 20;

    public static void main(String[] args) {
        int localVar = 10;
        Runnable r = () -> System.out.println(localVar + staticVar);
        r.run();
    }
}

В этом примере localVar захватывается, так как он effectively final, а staticVar доступен, так как это статическое поле.

#java #lambda #capturing

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

Функциональный интерфейс — это интерфейс, содержащий ровно один абстрактный метод. В Java 8 и выше они активно используются для работы с лямбда-выражениями и потоками (Stream API).

Пример:

@FunctionalInterface
interface MyFunctionalInterface {
    void execute();
}

public class Main {
    public static void main(String[] args) {
        MyFunctionalInterface task = () -> System.out.println("Hello, Functional Interface!");
        task.execute();
    }
}

✔️ Особенности:

1️⃣ Интерфейс с аннотацией @FunctionalInterface может содержать только один абстрактный метод.
2️⃣ Можно добавлять default или static методы без ограничения их количества.

💡 Совет: Используйте функциональные интерфейсы для создания компактного и чистого кода с лямбда-выражениями.

#java #functionalinterface #lambda

⌨️ Лямбда-выражения и свой кастомный функциональный интерфейс

Для того что бы определить лямбда-выражение, нам нужен функциональный интерфейс. Изобретём свой:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Функциональный интерфейс MathOperation содержит один абстрактный метод operate, который принимает два значения типа int и возвращает int. Аннотация @FunctionalInterface указывает на то, что интерфейс предназначен для использования в функциональном программировании и должен содержать только один абстрактный метод. Но аннотация не обязательна.

Использование лямбда-выражения:

public class LambdaExample {
    public static void main(String[] args) {
        // Реализация интерфейса с помощью лямбда-выражения
        MathOperation addition = (a, b) -> a + b;
        MathOperation subtraction = (a, b) -> a - b;
        MathOperation multiplication = (a, b) -> a * b;
        MathOperation division = (a, b) -> a / b;

        int x = 10;
        int y = 5;

        System.out.println("Addition: " + operate(x, y, addition)); // 15
        System.out.println("Subtraction: " + operate(x, y, subtraction)); // 5
        System.out.println("Multiplication: " + operate(x, y, multiplication)); // 50
        System.out.println("Division: " + operate(x, y, division)); // 2
    }

    // Метод, принимающий MathOperation и применяющий его к данным
    private static int operate(int a, int b, MathOperation operation) {
        return operation.operate(a, b);
    }
}

В нашем примере лямбда-выражения используются для создания экземпляров интерфейса MathOperation для выполнения различных математических операций (сложение, вычитание и т.д.).

Метод operate принимает два целых числа и функциональный интерфейс MathOperation, затем выполняет переданную операцию. В метод в третьем параметре можно передать непосредственно лямбда-выражение, не используя промежуточную переменную.

#java #lambda #FunctionalInterface

⌨️ Суть лямбда-выражений

Лямбда-выражения на первый взгляд могут показаться чем-то сложным и загадочным, но на самом деле они просты и интуитивно понятны.

Лямбда-выражение — это лаконичный способ описания анонимной функции, которую можно передать в качестве параметра или сохранить в переменной для последующего использования.

Если говорить ещё проще, лямбда-выражение — это просто другой способ создания и реализации объекта определённого типа. Рассмотрим это на примере создания нового потока.

У класса Thread есть конструктор:

public Thread(Runnable target) {
    ...
}

То есть в конструктор нужно передать объект типа Runnable. До лямбда-выражений мы сделали бы так:

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}).start();

Здесь мы создаём анонимный класс, реализующий интерфейс Runnable, с определённым методом run.
Если использовать лямбда-выражение, тот же код будет выглядеть следующим образом:

Runnable r = () -> System.out.println("Hello World");
new Thread(r).start();

Или проще:

new Thread(() -> System.out.println("Hello World")).start();

Лямбда-выражение заменяет собой анонимный класс, который раньше был бы необходим для реализации Runnable. Лямбда-выражение может использоваться только там, где ожидается реализация функционального интерфейса — интерфейса с единственным абстрактным методом.
А интерфейс Runnable именно такой:

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Функциональный интерфейс должен содержать только один абстрактный метод, чтобы компилятор мог точно определить, какой метод реализует лямбда-выражение. В противном случае возникли бы неоднозначности и ошибки.

#java #lambda #Runnable

⌨️ Поддержка лямбда выражений в своём коде

В Java лямбда-выражения используются с функциональными интерфейсами, которые имеют ровно один абстрактный метод. Например, стандартный функциональный интерфейс Function из пакета java.util.function представляет собой типичный пример.

Для нашего примера используем встроенный функциональный интерфейс IntUnaryOperator. Он выглядит вот так:

@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}

Этот интерфейс представляет функцию, которая принимает один аргумент типа int и возвращает значение типа int.

import java.util.function.IntUnaryOperator;

public class Main {
    public static int applyOperation(int number, IntUnaryOperator operator) {
        return operator.applyAsInt(number);
    }

    public static void main(String[] args) {
        int number = 5;

        // Лямбда-выражение для удвоения значения
        IntUnaryOperator doubleOperation = x -> x * 2;
        System.out.println("Double: " + applyOperation(number, doubleOperation)); // Double: 10

        // Лямбда-выражение для увеличения значения на 10
        IntUnaryOperator addTenOperation = x -> x + 10;
        System.out.println("Add Ten: " + applyOperation(number, addTenOperation)); // Add Ten: 15
    }
}

В нашем примере метод applyOperation принимает два параметра: число и функциональный интерфейс IntUnaryOperator. Лямбда-выражение используется для определения конкретной функции.

#java #lambda #IntUnaryOperator