Для кого предназначена эта статья?
  • Для тех, кто читал первую часть этой статьи;

  • для тех, кто считает, что уже неплохо знает Java Core, но понятия не имеет о лямбда-выражениях в Java. Или, возможно, что-то уже слышал про лямбды, но без подробностей.

  • для тех, у кого есть какое-то понимание лямбда-выражений, но использовать их до сих пор боязно и непривычно.
Популярно о лямбда-выражениях в Java. С примерами и задачами. Часть 2 - 1Если вы не входите в одну из этих категорий, вам эта статья вполне может показаться скучной, некорректной и вообще «не айс». В таком случае либо смело проходите мимо, либо, если вы хорошо разбираетесь в теме, предложите в комментариях, как я мог бы улучшить или дополнить статью. Материал не претендует на какую-либо академическую ценность, и уж тем-более на новизну. Скорее, наоборот: в ней я попытаюсь описать сложные (для кого-то) вещи как можно проще. На написание меня подвигла просьба объяснить stream api. Я подумал, и решил, что без понимания лямбда-выражений, часть моих примеров о «стримах» будет непонятна. Так что для начала — лямбды.

Доступ к внешним переменным

Скомпилируется ли такой код с анонимным классом?
int counter = 0;
Runnable r = new Runnable() {
    @Override
    public void run() {
        counter++;
    }
};
Нет. Переменная counter должна быть final. Или не обязательно final, но в любом случае изменять свое значение она не может. Тот же принцип используется и в лямбда-выражениях. Они имеют доступ ко всем переменным, которые им «видны» из того места, где они объявлены. Но лямбда не должна их изменять (присваивать новое значение). Правда, есть вариант обхода этого ограничения в анонимных классах. Достаточно лишь создать переменную ссылочного типа и менять внутреннее состояние объекта. При этом сама переменная будет указывать на тот же объект, и в таком случае можно смело указывать её как final.
final AtomicInteger counter = new AtomicInteger(0);
Runnable r = new Runnable() {
    @Override
    public void run() {
        counter.incrementAndGet();
    }
};
Здесь у нас переменная counter является ссылкой на объект типа AtomicInteger. А для изменения состояния этого объекта используется метод incrementAndGet(). Значение самой переменной во время работы программы не меняется и всегда указывает на один и тот же объект, что позволяет нам объявить переменную сразу с ключевым словом final. Эти же примеры, но с лямбда-выражениями:
int counter = 0;
Runnable r = () -> counter++;
Не скомпилируется по той же причине, что и вариант с анонимным классом: counter не должна меняться во время работы программы. Зато вот так — все нормально:
final AtomicInteger counter = new AtomicInteger(0);
Runnable r = () -> counter.incrementAndGet();
Это касается и вызова методов. Изнутри лямбда-выражения можно не только обращаться ко всем «видимым» переменным, но и вызывать те методы, к которым есть доступ.
public class Main {
    public static void main(String[] args) {
        Runnable runnable = () -> staticMethod();
        new Thread(runnable).start();
    }

    private static void staticMethod() {
        System.out.println("Я - метод staticMethod(), и меня только-что кто-то вызвал!");
    }
}
Хотя метод staticMethod() и приватный, но он «доступен» для вызова внутри метода main(), поэтому точно так же доступен для вызова изнутри лямбды, которая создана в методе main.

Момент выполнения кода лямбда-выражения

Возможно, вам этот вопрос покажется слишком простым, но его всё следует задать: когда выполнится код внутри лямбда-выражения? В момент создания? Или же в тот момент, когда (еще и неизвестно где) оно будет вызвано? Проверить довольно просто.
System.out.println("Запуск программы");

// много всякого разного кода
// ...

System.out.println("Перед объявлением лямбды");

Runnable runnable = () -> System.out.println("Я - лямбда!");

System.out.println("После объявления лямбды");

// много всякого другого кода
// ...

System.out.println("Перед передачей лямбды в тред");
new Thread(runnable).start();
Вывод на экран:
Запуск программы
Перед объявлением лямбды
После объявления лямбды
Перед передачей лямбды в тред
Я - лямбда!
Видно, что код лямбда-выражения выполнился в самом конце, после того, как был создан тред и лишь когда процесс выполнения программы дошел до фактического выполнения метода run(). А вовсе не в момент его объявления. Объявив лямбда-выражение, мы лишь создали объект типа Runnable и описали поведение его метода run(). Сам же метод был запущен значительно позже.

Method References (Ссылки на методы)?

Не имеет прямого отношения к самим лямбдам, но я считаю, что будет логично сказать об этом пару слов в этой статье. Допустим, у нас есть лямбда-выражение, которое не делает ничего особенного, а просто вызывает какой-то метод.
x -> System.out.println(x)
Ему передали некий х, а оно — просто вызвало System.out.println() и передало туда х. В таком случае, мы можем заменить его на ссылку на нужный нам метод. Вот так:
System.out::println
Да, без скобок в конце! Более полный пример:
List<String> strings = new LinkedList<>();
strings.add("мама");
strings.add("мыла");
strings.add("раму");

strings.forEach(x -> System.out.println(x));
В последней строке мы используем метод forEach(), который принимает объект интерфейса Consumer. Это снова же функциональный интерфейс, у которого только один метод void accept(T t). Соответственно, мы пишем лямбда-выражение, которое принимает один параметр (поскольку он типизирован в самом интерфейсе, тип параметра мы не указываем, а указываем, что называться он у нас будет х). В теле лямбда-выражения пишем код, который будет выполняться при вызове метода accept(). Здесь мы просто выводим на экран то, что попало в переменную х. Сам же метод forEach() проходит по всем элементам коллекции, вызывает у переданного ему объекта интерфейса Consumer (нашей лямбды) метод accept(), куда и передает каждый элемент из коллекции. Как я уже сказал, такое лямбда-выражение (просто вызывающее другой метод) мы можем заменить ссылкой на нужный нам метод. Тогда наш код будет выглядеть так:
List<String> strings = new LinkedList<>();
strings.add("мама");
strings.add("мыла");
strings.add("раму");

strings.forEach(System.out::println);
Главное, чтобы совпадали принимаемые параметры методов (println() и accept()). Поскольку метод println() может принимать что угодно (он перегружен для всех примитивов и для любых объектов, мы можем вместо лямбда-выражения передать в forEach() просто ссылку на метод println(). Тогда forEach() будет брать каждый элемент коллекции и передавать его напрямую в метод println(). Кто сталкивается с этим впервые, обратите внимание, что мы не вызываем метод System.out.println() (с точками между словами и со скобочками в конце), а именно передаем саму ссылку на этот метод. При такой записи
strings.forEach(System.out.println());
у нас будет ошибка компиляции. Поскольку перед вызовом forEach() Java увидит, что вызывается System.out.println(), поймет, что возвращается void и будет пытаться этот void передать в forEach(), который там ждет объект типа Consumer.

Синтаксис использования Method References

Он довольно прост:
  1. Передаем ссылку на статический метод ИмяКласса:: имяСтатическогоМетода?

    public class Main {
        public static void main(String[] args) {
            List<String> strings = new LinkedList<>();
            strings.add("мама");
            strings.add("мыла");
            strings.add("раму");
    
            strings.forEach(Main::staticMethod);
        }
    
        private static void staticMethod(String s) {
            // do something
        }
    }
  2. Передаем ссылку на не статический метод используя существующий объект имяПеременнойСОбъектом:: имяМетода

    public class Main {
        public static void main(String[] args) {
            List<String> strings = new LinkedList<>();
            strings.add("мама");
            strings.add("мыла");
            strings.add("раму");
    
            Main instance = new Main();
            strings.forEach(instance::nonStaticMethod);
        }
    
        private void nonStaticMethod(String s) {
            // do something
        }
    }
  3. Передаем ссылку на не статический метод используя класс, в котором реализован такой метод ИмяКласса:: имяМетода

    public class Main {
        public static void main(String[] args) {
            List<User> users = new LinkedList<>();
            users.add(new User("Вася"));
            users.add(new User("Коля"));
            users.add(new User("Петя"));
    
            users.forEach(User::print);
        }
    
        private static class User {
            private String name;
    
            private User(String name) {
                this.name = name;
            }
    
            private void print() {
                System.out.println(name);
            }
        }
    }
  4. Передаем ссылку на конструктор ИмяКласса::new
    Использование ссылок на методы очень удобно, когда есть готовый метод , который вас полностью устраивает, и вы бы хотели использовать его в качестве callback-а. В таком случае, вместо того чтобы писать лямбда-выражение с кодом того метода, или же лямбда-выражение, где мы просто вызываем этот метод, мы просто передаем ссылку на него. И всё.

Интересное различие между анонимным классом и лямбда-выражением

В анонимном классе ключевое слово this указывает на объект этого анонимного класса. А если использовать this внутри лямбды, мы получим доступ к объекту обрамляющего класса. Того, где мы это выражение, собственно, и написали. Так происходит потому, что лямбда-выражения при компиляции превращаются в приватный метод того класса, где они написаны. Использовать эту «фичу» я бы не рекомендовал, поскольку у неё есть побочный эффект (side effect), что противоречит принципам функционального программирования. Зато такой подход вполне соответствует ООП. ;)

Откуда я брал информацию или что почитать еще