Курс Модуль 2. Java Core - Лекция: Предыстория появления Лямбда-выражений

1. Интерфейсы

Чтобы понимать, что такое лямбда-функции, сначала нужно понимать, что такое интерфейсы. Поэтому напомним основные моменты.

Интерфейс — это разновидность класса. Сильно урезанная, если можно так сказать. У интерфейса, в отличие от класса, не может быть своих переменных (кроме статических). Также нельзя создавать объекты типа Интерфейс:

Нельзя объявлять переменные класса
Нельзя создавать объекты

Пример:

interface Runnable
{
   void run();
}

Пример стандартного интерфейса

Использование интерфейса

Так зачем же интерфейс нужен? Интерфейсы используются только совместно с наследованием. Один и тот же интерфейс могут наследовать разные классы, или еще говорят, что классы реализуют интерфейс.

Если класс реализует интерфейс, он обязан реализовать у себя внутри те методы, которые были объявлены, но не реализованы внутри интерфейса. Пример:

interface Runnable
{
   void run();
}

class Timer implements Runnable
{
   void run()
   {
      System.out.println(LocalTime.now());
   }
}

class Calendar implements Runnable
{
   void run()
   {
      var date = LocalDate.now();
      System.out.println("Сегодня " + date.getDayOfWeek());
   }
}

Класс Timer реализует (implements) интерфейс Runnable, поэтому обязан объявить внутри себя все методы, которые есть в интерфейсе Runnable и реализовать их: написать код в теле метода. То же касается и класса Calendar.

Зато теперь в переменные типа Runnable можно сохранять ссылки на объекты классов, которые реализуют интерфейс Runnable.

Пример:

Код	Примечание
`Timer timer = new Timer(); timer.run(); Runnable r1 = new Timer(); r1.run(); Runnable r2 = new Calendar(); r2.run();`	Будет вызван метод `run()` класса `Timer` Будет вызван метод `run()` класса `Timer` Будет вызван метод `run()` класса `Calendar`

Вы всегда можете присвоить ссылку на объект переменной любого типа, если этот тип — один из классов-родителей объекта. Для классов Timer и Calendar таких типов два: Object и Runnable.

Если вы присвоите ссылку на объект переменной типа Object, сможете вызывать у нее только методы, объявленные в классе Object. А если присвоите ссылку на объект переменной типа Runnable, сможете вызвать у нее методы, которые есть в типе Runnable.

Пример 2:

ArrayList<Runnable> list = new ArrayList<Runnable>();
list.add (new Timer());
list.add (new Calendar());

for (Runnable element: list)
    element.run();

Такой код будет работать, ведь у объектов Timer и Calendar есть отличные рабочие методы run. Поэтому нет никаких проблем с тем, чтобы их вызвать. Если бы мы просто добавили метод run() в оба класса, не смогли бы вызвать их таким простым способом.

Интерфейс Runnable фактически используется только для того, чтобы было куда поместить метод run.

2. Сортировка

Давайте перейдем к чему-то более практичному. Например, рассмотрим сортировку строк.

Чтобы сортировать коллекцию строк в алфавитном порядке, в Java есть отличный метод — Collections.sort(коллекция);

Этот статический метод выполняет сортировку переданной коллекции, и в процессе сортировки попарно сравнивает ее элементы: чтобы понять, менять элементы местами или нет.

Сравнение элементов в процессе сортировки выполняется с помощью метода compareTo(), который есть у всех стандартных классов: Integer, String, ...

Метод compareTo() класса Integer сравнивает значения двух чисел, а метод compareTo() класса String смотрит на алфавитный порядок строк.

Таким образом, коллекция чисел будет отсортирована в порядке их возрастания, а коллекция строк — в алфавитном порядке.

Альтернативная сортировка

А если мы хотим сортировать строки не по алфавиту, а по их длине? И числа хотим сортировать в порядке убывания. Как быть в этой ситуации?

Для этого у класса Collections есть еще один метод sort(), но уже с двумя параметрами:

Collections.sort(коллекция, компаратор);

Где компаратор — это специальный объект, который знает, как сравнивать объекты в коллекции в процессе сортировки. Компаратор происходит от английского слова Comparator (сравнитель), а Comparator — от слова Compare — сравнивать.

Так что же это за специальный объект-то такой?

Интерфейс Comparator

На самом деле все очень просто. Тип второго параметра метода sort() — Comparator<T>

Где T — это тип-параметр, такой же, как и тип элементов коллекции, а Comparator — это интерфейс, который имеет единственный метод int compare(T obj1, T obj2);

Другими словами, объект-компаратор — это любой объект класса, который реализует интерфейс Comparator. Выглядит интерфейс Comparator очень просто:

public interface Comparator<Tип>
{
   public int compare(Tип obj1, Tип obj2);
}

Код интерфейса Comparator

Метод compare() сравнивает два параметра, которые в него передают.

Если метод возвращает отрицательное число, то obj1 < obj2. Если метод возвращает положительное число, то obj1 > obj2. Если метод возвращает 0, то считается, что obj1 == obj2.

Вот как будет выглядеть объект компаратор, который сравнивает строки по их длине:

public class StringLengthComparator implements Comparator<String>
{
   public int compare (String obj1, String obj2)
   {
      return obj1.length() - obj2.length();
   }
}

Код класса StringLengthComparator

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

Полный код программы, которая сортирует строки по длине, будет выглядеть вот так:

public class Solution
{
   public static void main(String[] args)
   {
      ArrayList<String> list = new ArrayList<String>();
      Collections.addAll(list, "Привет", "как", "дела?");
      Collections.sort(list, new StringLengthComparator());
   }
}

class StringLengthComparator implements Comparator<String>
{
   public int compare (String obj1, String obj2)
   {
      return obj1.length() - obj2.length();
   }
}

Сортировка строк по длине

3. Синтаксический сахар

А как вы думаете, можно ли записать данный код короче? По сути, тут только одна строка, которая несет полезную информацию — obj1.length() - obj2.length();.

Но ведь код не может существовать вне метода, поэтому пришлось добавить метод compare(), а для метода пришлось добавить новый класс – StringLengthComparator. И еще типы переменных нужно указывать... В общем, вроде бы все правильно.

Однако, есть способы записать этот код короче. У нас для вас припасено немного синтаксического сахара. Ведра эдак два!

Анонимный внутренний класс

Вы можете записать код компаратора прямо внутри метода main(), а компилятор сам сделает все остальное. Пример:

public class Solution
{
    public static void main(String[] args)
    {
        ArrayList<String> list = new ArrayList<String>();
        Collections.addAll(list, "Привет", "как", "дела?");

        Comparator<String> comparator = new Comparator<String>()
        {
            public int compare (String obj1, String obj2)
            {
                return obj1.length() - obj2.length();
            }
        };

        Collections.sort(list, comparator);
    }
}

Сортировка строк по длине

Вы можете создать объект наследник интерфейса Comparator, не создавая сам класс! Компилятор создаст его автоматически и даст ему какое-нибудь временное имя. Сравните:

Comparator<String> comparator = new Comparator<String>()
{
    public int compare (String obj1, String obj2)
    {
        return obj1.length() - obj2.length();
    }
};

Анонимный внутренний класс

Comparator<String> comparator = new StringLengthComparator();

class StringLengthComparator implements Comparator<String>
{
    public int compare (String obj1, String obj2)
    {
        return obj1.length() - obj2.length();
    }
}

Класс StringLengthComparator

Одинаковым цветом раскрашены одинаковые блоки кода в двух разных случаях. Отличия совсем небольшие на самом деле.

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

4. Лямбда-выражения в Java

Допустим, вы решили использовать в вашем коде анонимный внутренний класс. В этом случае у вас будет блок кода типа такого:

Comparator<String> comparator = new Comparator<String>()
{
    public int compare (String obj1, String obj2)
    {
        return obj1.length() - obj2.length();
    }
};

Анонимный внутренний класс

Тут и объявление переменной, и создание анонимного класса — все вместе. Однако есть способ записать этот код короче. Например, так:

Comparator<String> comparator = (String obj1, String obj2) ->
{
    return obj1.length() - obj2.length();
};

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

Такая запись называется лямбда-выражением.

Если компилятор встретит такую запись в вашем коде, он просто сгенерирует по ней полную версию кода (с анонимным внутренним классом).

Обратите внимание: при записи лямбда-выражения мы опустили не только имя класса Comparator<String>, но и имя метода int compare().

У компилятора не возникнет проблем с определением метода, т.к. лямбда-выражение можно писать только для интерфейсов, у которых метод один. Впрочем есть способ обойти это правило, но об этом вы узнаете, когда начнете изучать ООП активнее (мы говорим о default-методах).

Давайте еще раз посмотрим на полную версию кода, только раскрасим серым цветом ту ее часть, которую можно опустить при записи лямбда выражения:

Comparator<String> comparator = new Comparator<String>()
{
    public int compare (String obj1, String obj2)
    {
      return obj1.length() - obj2.length();
    }
};

Анонимный внутренний класс

Вроде бы ничего важного не упустили. Действительно, если у интерфейса Comparator есть только один метод compare(), по оставшемуся коду компилятор вполне может восстановить серый код.

Сортировка

Кстати, код вызова сортировки теперь можно записать так:

Comparator<String> comparator = (String obj1, String obj2) ->
{
   return obj1.length() - obj2.length();
};
Collections.sort(list, comparator);

Или даже так:

Collections.sort(list, (String obj1, String obj2) ->
   {
      return obj1.length() - obj2.length();
   }
);

Мы просто подставили вместо переменной comparator сразу то значение, которое присваивали переменной comparator.

Выведение типов

Но и это еще не все. Код в этих примерах можно записать еще короче. Во-первых, компилятор может сам определить, что у переменных obj1 и obj2 тип String. А во-вторых, фигурные скобки и оператор return тоже можно не писать, если у вас в коде метода всего одна команда.

Сокращенный вариант будет таким:

Comparator<String> comparator = (obj1, obj2) ->
   obj1.length() - obj2.length();

Collections.sort(list, comparator);

А если вместо переменной comparator сразу подставить ее значение, то получим такой вариант:

Collections.sort(list, (obj1, obj2) ->  obj1.length() - obj2.length() );

Ну и как вам: всего одна строка кода, никакой лишней информации — только переменные и код. Короче уже некуда! Или есть куда?

5. Как это работает

На самом деле, код можно записать еще короче. Но об этом чуть позже.

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

Например, в этом коде Collections.sort(list, (obj1, obj2) -> obj1.length() - obj2.length()); можно записать лямбда-выражение, т.к. сигнатура метода sort() имеет вид:

sort(Collection<T> colls, Comparator<T> comp)

Когда мы передали в метод sort в качестве первого параметра коллекцию ArrayList<String>, компилятор смог определить тип второго параметра как Comparator<String>. А из этого сделал вывод, что этот интерфейс имеет единственный метод int compare(String obj1, String obj2). Остальное уже дело техники.

Комментарии (274)

ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ

Misha Уровень 20

12 октября 2024


package com.javarush.task.pro.task18.task1804;

import java.util.ArrayList;
import java.util.Collections;

/* 
Знакомство с лямбда-выражением
*/

public class Solution {

    public static void main(String[] args) {
        var numbers = new ArrayList<Integer>();

        Collections.addAll(numbers, 123, -6, 12, 0, 44, 5678, -350);

        sortNumbers(numbers);

        for (Integer number : numbers) {
            System.out.println(number);
        }
    }

    public static void sortNumbers(ArrayList<Integer> numbers) {
        Collections.sort(numbers, (i1, i2) -> i1 - i2);
    }
}

Ромушка Роман Уровень 24

8 октября 2024

Сразу видно, что это писал тот человек, который был с нами с 1 уровня. Предыдущий уровень будто дали на откуп кому-то другому, кто написал что-то в общем, не слишком глубоко. Поэтому здесь решили написать про интерфейсы с элементарным выводом о его работе. А тема реально классная.

qaseqiara Уровень 25

18 сентября 2024

кайф тема

Denzol255 Уровень 23

2 сентября 2024

Мысли при чтении пункта 2: "Для сортировки в Java нужно создавать отдельный класс, имплементировать интерфейс, писать метод. Вот у нас в JS всё просто написал стрелочную функцию в методе sort и всё" Пункт 5: "А, ну понятно... Тут тоже стрелка и вычисляемый на ходу тип параметров..."

Антон Карпов Уровень 29

27 августа 2024

Отличная тема 🙂 Уже несколько раз встречал лямбда выражения, которые просто в ступор вводили. Казалось, что это какая-то магия непонятная. А теперь картинка проясняется)

Оганнес Хачатрян Уровень 23 Expert

17 августа 2024

Я уже понял что делает Компаратор в Java, но не в майнкрафте....

Михаил Федосов Уровень 26

16 августа 2024

Круто, лекция содержит новый материал даже для опытных программистов на другом языке! За это я и платил )

Евгений Маркин Уровень 32

7 августа 2024

ВНИМАНИЕ! по последней задаче про прощание компилятор глючит. Если у Вас в идее решение компилируется правильно, то что нужно сделать: 1. Сбросить прогресс задачи 2. Отправить на проверку 3. Добавить файл с компаратором 4. Отправить на проверку 5. Написать реализацию компаратора, не забыв добавить импорт import java.util.Comparator; 6. Отправить на проверку 7. Написать сортировку в солюшене 8. Отправить на проверку. Вуаля задача пройдена. P.S. Блин два часа на этот глюк убил.

FolFix Уровень 32

6 августа 2024

Я конечно приафигел сейчас

Mikhail Tabakaev Уровень 29

17 июля 2024

круто. первый способ (без лямбдов всяких) по классике (класс от компаратора) мне показался наиболее безопасным и удобным для использования в реальных условиях. благодарствую! пошел впиливать этот прием в свой пет-проект)