Вопрос по лямбде

Поняла, у нас основной действующий метод — sort(), а компаратор описывает принцип, по которому sort() работает. А можешь, пожалуйста, подсказать, после лямбды идет рассказ про :: в контексте того, что выражение

list.forEach( s -> System.out.println(s) );

можно заменить на

list.forEach( System.out::println );

и вот тут меня смущает "откуда метод знает, какие аргументы мы передаем". верно ли, что ссылку на метод мы можем передать только в метод forEach, где мы подразумеваем, что для каждого элемента коллекции выполним какой-то метод?

Или логика в том, что метод forEach() принимает в качестве параметра объект интерфейса Consumer, и т.к. у Consumer единственный абстрактный метод, то нам подойдет любой другой метод с такой же сигнатурой + типом возвращаемого значения. То есть с помощью такой строчки: list.forEach( System.out::println ); , такой код:

public interface Consumer<T> {
    void accept(T t);
}

Идея переписывает вот так:

public interface Consumer<T> {
    void accept(T t) {
        System.out.println(t);
    }
}

Похоже, кому-то нужно глубже погрузиться в мир Stream API. 😄 Если открыть класс Stream и посмотреть его методы, ты увидишь, что у метода forEach аргументом является Consumer, т.е. "потребитель", способный "потребить" любой объект, являющийся родителем для элементов стрима:

void forEach(Consumer<? super T> action)

Consumer - это такой вид функциональных интерфейсов в Java, который содержит один метод типа void с одним аргументом. Т.е. другими словами, он "потребляет" аргумент и ничего не возвращает взамен, потому он и потребитель. Есть и другие виды функциональных интерфейсов: Function, принимающий аргумент одного типа и преобразующий его в объект другого типа, Supplier, т.е. поставщик, не имеющий аргументов и возвращающий объект определенного типа и другие. Подробнее можешь почитать по запросу "Функциональные интерфейсы Java". Можно писать и свои функциональные интерфейсы. Вообще технически функциональным интерфейсом является интерфейс, имеющий только один метод. В этом случае этот метод можно заменить анонимной функцией (лямбдой), поэтому они и называются функциональными. Так вот, возвращаясь к forEach. Если у нас аргументом является консьюмер, то это значит, что мы можем создать объект этого типа, сохранить в переменную и затем передать ее в метод forEach аргументом, правильно? Давай так и сделаем. <? super T> означает, что дженериком в консьюмере может быть любой объект, от которого наследуется тип элементов коллекции. Логика такая, что если консьюмер может принять аргументом Object, то он сможет принять и String, который хранится в коллекции.

public static void main(String[] args) throws Exception {
    List<String> strings = Arrays.asList("alpha", "bravo", "charlie", "", "echo");
    Consumer<String> println = new Consumer<String>() {
        @Override
        public void accept(String x) {
            System.out.println(x);
        }
    };
    strings.forEach(println);
}

Консьюмер как функциональный интерфейс можно заменить лямбда-функцией, выполняющей содержимое метода accept: Consumer<String> println = x -> {System.out.println(x);}; А если у тебя есть какой-то готовый метод, у которого есть один аргумент подходящего типа, который при этом ничего не возвращает, то ты можешь буквально сказать следующее: вот есть метод, подпадающий под требования консьюмера, создай анонимный класс, реализующий консьюмер, чтобы в теле метода accept этого анонимного консьюмера выполнился метод, ссылку на который я передаю в аргументе. И тогда под капотом происходит всё описанное выше. Можно описать какой-нибудь свой функциональный метод, подпадающий под эти требования:

public class FuncInterfaceTest {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("alpha", "bravo", "charlie", "", "echo");

        strings.forEach(FuncInterfaceTest::printUpper);
    }

    private static void printUpper(String x) {
        System.out.println(x.toUpperCase());
    }
}

И о вопросе, куда ещё можно передавать ссылки на методы. Как ты уже сама правильно написала, их можно передавать в методы, принимающие в качестве аргумента какой-то функциональный интерфейс. Например метод Stream#map() принимает тип Function, а метод filter принимает Predicate. С помощью Function можно преобразовать имеющиеся элементы, а с помощью Predicate проверить, соответствуют ли они определённым условиям:

public class FuncInterfaceTest {

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("alpha", "bravo", "charlie", "", "echo");

        strings.stream()
               .map(String::toUpperCase)
               .forEach(System.out::println);

        int emptyCount = (int) strings.stream()
                                      .filter(String::isEmpty)
                                      .count();
        System.out.println(emptyCount + " empty strings in list");
    }
}

Другой пример:

public static void main(String[] args) {
    List<String> numStrings = Arrays.asList("4", "8", "15", "16", "23", "42");
    int sum = numStrings.stream()
                        .mapToInt(Integer::parseInt)
                        .sum();
    System.out.println(sum);
}

Я тебе уже как-то скидывал пример калькулятора, который реализовал при помощи енама с видами операторов, каждый из которых содержал в себе поле типа BiFunction, то есть функциональный интерфейс, принимающий два аргумента и возвращающий значение - то, что нужно для выполнения арифметической операции. Возможно, после знакомства с этими материалами, с ним станет проще разобраться. Напоследок полезная ссылка: https://habr.com/ru/company/luxoft/blog/270383/

Большое спасибо! На первый раз эта тема далась нелегко, и я пошла повторять её последовательно, а стримы там идут подальше. И по моим личным впечатлениями, мне не хватило понимания метод рефенес для понимания стримов. Но вот сейчас прочитала твои ответы, и понимаю, что как ни крути, а изучать их надо прямо одновременно, чтобы понять. Правильно ли я понимаю, что тут основной затык, что ООП накладывается на ФП и в java функция фактически может быть объектом, в то время как в других ЯП есть просто "функция и метод". Поэтому на java все эти сущности: 1) анонимный класс 2) лямбда 3) метод референс — это возможность рассмотреть функцию как объект, и по сути нас интересует не столько функция сама по себе, сколько код, который она выполняет. То есть функциональный интерфейс это в прямом смысле интерфейс для функции (а не для класса), просто реализованный возможностями java. И для нас строчка "strings.forEach(FuncInterfaceTest::printUpper);" (или любая подобная, принимающая лямбду, анонимный класс или метод референс) говорит что-то вроде этого: "В методе forEach (или любом другом) сделано так, что в нужное время будет отрабатывать метод Х. Этот метод Х имеет определенные параметры и тип возвращаемого значения: - в метод Х будут передаваться такие-то параметры (или не передаваться вообще), - от этого метод Х мы ожидаем на выходе такой-то результат (возвращаемое значение или просто действие). То есть мы уже придумали, какого формата метод мы ждем, и как работать с этом методом. А теперь ты, программист, напиши, как именно сам этот метод Х будет работать, и какая внутри него будет логика. Вот и получается, что наш функциональный интерфейс сделал нам "чертеж нашего метода", а мы "накладываем" нужную нам реализацию с помощью функции, которая в данном контексте будет объектом. Это оно, или я ушла в какие-то не те дебри?

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

Спасибо!)