У меня возникли вопросы о лямбда-выражениях и RxJava. Эти вопросы в основном касаются не полного понимания лямбда-выражений или RxJava. Я попытаюсь объяснить лямбда-выражения как можно проще. RxJava я опишу отдельно.

Лямбда-выражения и RxJava

Что такое лямбда-выражения? Лямбда-выражения – это «всего лишь» новый способ сделать то же самое, что мы всегда могли сделать, но в более чистом и менее многословном новом способе использования анонимных внутренних классов.

Анонимный внутренний класс в Java – это класс без имени, он должен использоваться, если вам необходимо переопределить методы класса или интерфейса. Анонимный внутренний класс может быть создан из класса или интерфейса.

Например:

abstract class Animal {
   abstract void speak();
}

Animal a = new Animal() {
   void speak() {
       System.out.println("Woff");
   }
};

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

Button btn = findViewById(R.id.button);
btn.setOnClickListener(
       new View.OnClickListener() {
           @Override
           public void onClick(final View view) {
               // Do some fancy stuff with the view parameter.
           }
       }
);

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

new View.OnClickListener() {
   @Override
   public void onClick(final View view) {
       // Do some fancy stuff with the view parameter.
   }
}

Лямбда-выражения могут использоваться только в том случае, если вам нужно переопределить не более одного метода. К счастью для нас, View.OnClickListener содержит только один. Посмотрите на код ниже. Как думаете, какую его часть нам придётся убрать?

new View.OnClickListener() {
   @Override
   public void onClick(final View view) {
       // Do some fancy stuff with the view parameter.
   }
}

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

(view) -> {
   // Do some fancy stuff with the view parameter.
}

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

(View view) -> {
   // Do some fancy stuff with the view parameter.
}

Вы также можете использовать многострочный код:

(view) -> {
   Intent intent = new Intent(context, AuthActivity.class);
   intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |     Intent.FLAG_ACTIVITY_CLEAR_TASK);
   view.getContext().startActivity(intent);
} 

Если у вас есть интерфейс с методом, принимающим два параметра…

interface MyInterface {
   abstract void onMethod(int a, int b);
} 

…лямбда-выражение будет выглядеть следующим образом:

(a, b) -> {
   // Do some fancy stuff with the a and b parameter.
}

Если метод имеет возвращаемый тип…

interface MySecondInterface {
   abstract int onSecondMethod(int a, int b);
}

…лямбда-выражение будет выглядеть следующим образом:

(a, b) -> {
   return a + b;
}

Но это еще не все, есть некоторые специальные случаи, которые делают код еще меньше. Если тело вашего метода содержит только одну строку кода, вы можете удалить фигурные скобки {}. Если вы удаляете фигурные скобки, вам также необходимо удалить точку с запятой, оставив следующее:

(a, b) -> return a + b

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

(a, b) -> a + b

Если бы у нас был многострочный код, это свелось бы к следующему:

(a, b) -> {
   a+=1;
   return a + b;
}

Так что же мы сделали? Мы взяли это:

new MySecondInterface() {
   @Override
   public int onSecondMethod(final int a, final int b) {
       return a + b;
   }
};

и превратили вот в это:

(a, b) -> a + b

Осталось только одна вещь, ссылки на методы. Допустим, у нас есть интерфейс, как и раньше, и метод, который этот интерфейс принимает как параметр:

public interface Callback {
   public void onEvent(int event);
}

public void myMethod(Callback callback){

}

Без лямбда-выражения это выглядело бы так:

myMethod(new Callback() {
   @Override
   public void onEvent(final int state) {
       System.out.println(state);
   }
}); 

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

myMethod(state -> System.out.println(state));

Но это еще не все. Если используемый код – однострочный и вызываемая функция принимает один параметр, мы можем передавать ссылку на метод в таком виде:

myMethod(System.out::println);

Параметр будет передаваться автоматически, без необходимости использования другого кода! Удивительно, правда? Надеюсь, вы узнали что-то новое!