Java 8介绍了一个名为Lambda表达式的新函数。

它被认为是Java的一个重大变化。
由于这种变化将为Java带来函数规划。

其他语言如 Scala已经有这个函数，所以这对编程世界来说并不是新的，它是java的新函数

在理解Lambda表达之前，让我们先了解 Functional Interface。

什么是函数接口？

函数接口是那些只有一个抽象方法的接口。

它可以具有多个默认或者静态方法，可以从Java覆盖该方法。

lang.object。
让我们创建一个函数接口：

@FunctionalInterface
public interface Decorable {
 
 //one abstract method
 void decorateWithCurtains();
 
 //default method
 default void decorateWithPaints()
 {
  System.out.println("Decorating using paints");
 }
 
 //Overriding method of java.lang.Object
 @Override
 public int hashCode();
 
}

Java本身可以识别函数接口，但我们也可以通过使用@FunctionalInterface注释它来表示作为函数接口的接口。

一些流行的函数接口是：

• java.lang.runnable.runnable.Runnable.Runnable.
• java.util.concurrent.Callable.
• java.awt.Event.ActionListener.Event.ActionListener.
• java.util.Comparator.

为什么lambda表达式？

让我们随着匿名比较者的帮助而理解：

假设我们需要通过电影名称对电影列表进行排序。 Movie.java

package org.igi.theitroad;
 
public class Movie {
 
	String movieName;
	long duration;
	
	public Movie(String movieName, long duration) {
		super();
		this.movieName = movieName;
		this.duration = duration;
	}
	
	//getters and setters
}

使用比较器按名称排序电影列表的代码

Movie m1=new Movie("Inception",110);
    Movie m2=new Movie("GodFather",200);
    Movie m3=new Movie("Forest Gump",130);
    Movie m4=new Movie("Avengers",150);
    
    List<Movie> listOfMovies = new ArrayList<>();
    listOfMovies.add(m1);
    listOfMovies.add(m2);
    listOfMovies.add(m3);
    listOfMovies.add(m4);
 
    System.out.println("Before Sort by name : ");
    for (int i = 0; i < listOfMovies.size(); i++) {
      Movie movie = (Movie) listOfMovies.get(i);
      System.out.println(movie);
          
    }
    //Sort by movieName
    //Anonymous Comparator
    //old way
    Collections.sort(listOfMovies, new Comparator<Movie>() {
      @Override
      public int compare(Movie o1, Movie o2) {
        return o1.getMovieName().compareTo(o2.getMovieName());
      }
    });

匿名比较器的问题是语法。
每次要使用比较器对列表进行排序时，我们必须记住庞大的语法。

这么一般是主要问题 Anonymous classes是语法。
对于非常简单的操作，我们需要编写复杂的代码。
为了解决这个问题，JDK推出了一个名为Lambda表达式的新函数。
解释Lambda表达以了解，如何理解，我将如何参加这个例子 lambda expression将减少这个复杂的代码。

什么是lambda表达式：

lambda表达式代表匿名函数。
它包括一组参数，Lambda运算符( - >)和函数体。
你可以称之为 function without name那

Lambda表达式与函数接口之间的连接：

我们可能认为我已经推出了上面的函数接口，但它是如何连接到Lambda的。
因此，Lambda表达式可以应用于匿名实现或者正在匿名实施的函数接口的抽象方法。

Lambda表达的结构

(Argument List) ->{expression;} or
(Argument List) ->{statements;}

所以我们可以将Lambda表达的结构分为三个部分：

• 参数列表或者参数
• Lambda表达可以具有零个或者更多个参数。
• () - > {system.out.println("hello")}; //没有参数，将打印hello(int a) - > {system.out.println(a)}; //一个参数，将打印值a(int a，int b) - > {a + b}; //两个参数，将返回这两个整数的总和
• (a,b)->{a+b}; //two argument, will return sum of these two numbers
• 我们可以选择不会声明参数的类型，因为它可以从上下文中推断出来。
• 我们无法声明一个参数的类型，也不会为其他参数声明类型。
• (int a，b) - > {a + b}; //汇编错误
• 当有一个参数时，如果推断出它的类型，则不强制使用括号a - > {system.out.println(a)}; //将打印数字a的值
• 数组令牌( - >)
• Body身体
• 可以表达或者语句。 statement如果只有一个
• 在身体中，不需要卷曲支撑，并且匿名函数的返回类型与身体表达式相同 statements如果有多个 curly braces，那它应该在 void返回类型的匿名函数与代码块的值返回相同，

如果没有任何返回。

public class ThreadSample {
 
 public static void main(String[] args) {
  
  //old way
  new Thread(new Runnable() {
   
   @Override
   public void run() {
    System.out.println("Thread is started");
   }
  }).start();
 
  //using lambda Expression
  new Thread(()->System.out.println("Thread is started")).start();
 }
 
}

让我们拍一些例子，你想初始化线程，现在你会意识到，Lambda表达如何让你的编码变得简单：

让我们拍摄我们在Java的匿名比较器中看到的比较器的另一个例子。

我们将创建电影列表并使用简单的方式和Lambda表达式通过电影名称对其进行排序。

package org.igi.theitroad;
 
public class Movie {
 
	String movieName;
	long duration;
	
	public Movie(String movieName, long duration) {
		super();
		this.movieName = movieName;
		this.duration = duration;
	}
	
	public String getMovieName() {
		return movieName;
	}
	public void setMovieName(String movieName) {
		this.movieName = movieName;
	}
	public long getDuration() {
		return duration;
	}
	public void setDuration(long duration) {
		this.duration = duration;
	}
	
	@Override
	public String toString() {
		return "Movie Name: " + this.getMovieName() + "|| " 
	    + "Movie duration: " + this.getDuration();
 
	}
}

创建一个名为movie.java的类

package org.igi.theitroad;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class ComparatorLambdaMain {
 
  /**
   * @author igi Mandliya
   */
  public static void main(String[] args) {
    
    Movie m1=new Movie("Inception",110);
    Movie m2=new Movie("GodFather",200);
    Movie m3=new Movie("Forest Gump",130);
    Movie m4=new Movie("Avengers",150);
    
    List<Movie> listOfMovies = new ArrayList<>();
    listOfMovies.add(m1);
    listOfMovies.add(m2);
    listOfMovies.add(m3);
    listOfMovies.add(m4);
 
    System.out.println("Before Sort by name : ");
    for (int i = 0; i < listOfMovies.size(); i++) {
      Movie movie = (Movie) listOfMovies.get(i);
      System.out.println(movie);
          
    }
    //Sort by movieName
    //Anonymous Comparator
    //old way
    Collections.sort(listOfMovies, new Comparator<Movie>() {
      @Override
      public int compare(Movie o1, Movie o2) {
        return o1.getMovieName().compareTo(o2.getMovieName());
      }
    });
    
    //Using lambda expression
    Collections.sort(listOfMovies, (o1, o2) -> o1.getMovieName().compareTo(o2.getMovieName()));
 
    System.out.println("After Sort by name: ");
    for (int i = 0; i < listOfMovies.size(); i++) {
      Movie movie = (Movie) listOfMovies.get(i);
      System.out.println(movie);
    }
  }
}

因此，尽管写作匿名比较器，但我们的表情变得非常容易。

所以我们通过了2个参数O1和O2，我们没有通过类型，因为它可以从上下文推断出来。

我们这里只有一个语句，所以无需将它放在卷曲的括号中。

HelloWorld Lambda表达式示例

package org.igi.theitroad;
 
   public interface HelloWorld {
       void sayHello();
}

创建一个名为helloworld的接口

package org.igi.theitroad;
 
public class HelloWorldMain {
 
 public static void main(String args[])
 {
     //Lambda Expression 
     HelloWorld helloWorld=()->System.out.println("Hello using Lambda Expression");
    helloWorld.sayHello();
 }
}