PDF Document Uploaded Github 


Chapter one  Lambda

1.1  introduction

The textbook says there are two modes of programming , Process oriented programming and object oriented programming , In fact, there was function oriented programming before object-oriented programming ( Functional programming ) , It used to be ignored 、 Don’t be seriously , Now from academia to business , Support for functional programming languages currently has Scala、Erlang、F#、Python、Php、Java、Javascript etc. , Some say it’s going to be the next mainstream in programming languages …

1.2 Lambda expression

Why Lambda expression ?

1. Use Lambda Expressions can make code more compact , For example, in Java To implement a thread , Output only one string Hello World!, Our code is as follows :

public static void main(String[] args) throws Exception {
new Thread(new Runnable() {
public void run() {
System.out.println("Hello World!");

Use Lambda After the expression, the code becomes the following form :

public static void main(String[] args) throws Exception {
new Thread(() -> System.out.println("Hello World!")).start();

Is the code becoming more compact ~, Others, such as various monitors , And event handlers can be simplified in this way .

2. The ability to modify methods , In fact, it’s plain , That is, a function can accept parameters with a function as a unit , stay C/C++ In this case, the function pointer , stay Java The middle is Lambda expression , For example, in Java Use set classes to sort a string in a dictionary sequence , The code is as follows :

public static void main(String[] args) {
String []datas = new String[] {"peng","zhao","li"};
Stream.of(datas).forEach(param -> System.out.println(param));

In the above code Arrays Inside sort Method , Now we don’t need to sort by Dictionary , It’s sort by the length of the string , The code is as follows :

public static void main(String[] args) {
String []datas = new String[] {"peng","zhao","li"};
Arrays.sort(datas,(v1 , v2) -> Integer.compare(v1.length(), v2.length()));
Stream.of(datas).forEach(param -> System.out.println(param));

Is it convenient , We don’t need to achieve Comparable Interface , Use one Lambda Expression can change the shape of a function to ~

1.3 Syntax

1.Lambda The formal representation of the expression is as follows

Parameters -> an expression 

2. If Lambda Multiple statement blocks are executed in the expression , Multiple statement blocks need to be added to {} For packaging , If there is a return value , Need to show the specified return sentence , As shown below :

Parameters -> {expressions;};

3. If Lambda Expressions don’t need arguments , You can use an empty bracket to indicate , The following example shows

() -> {for (int i = 0; i < 1000; i++) doSomething();};

4.Java It’s a strongly typed language , So parameters have to be typed , If the compiler can infer Lambda The argument type of the expression , You don’t need to specify what we show , As shown below , stay Java It is speculated that Lambda The parameter types of expressions are basically similar to the methods of inferring generic types , as for Java How to deal with generics , Omitted here

String []datas = new String[] {"peng","zhao","li"};
Arrays.sort(datas,(String v1, String v2) -> Integer.compare(v1.length(), v2.length()));

In the above code   The display specifies the parameter type Stirng, Actually, it doesn’t specify , As shown in the following code , It’s OK, too , Because the compiler will be based on Lambda The functional interface corresponding to the expression Comparator<String> Make automatic inference

String []datas = new String[] {"peng","zhao","li"};;
Arrays.sort(datas,(v1, v2) -> Integer.compare(v1.length(), v2.length()));

5. If Lambda The expression has only one parameter , And the type of the parameter can be inferred by the compiler , Can be used as follows Lambda expression , That is, you can omit the type of parameter and bracket

Stream.of(datas).forEach(param -> {System.out.println(param.length());});

6.Lambda The return type of the expression , Do not need to specify , The compiler will infer , It’s self inference

7.Lambda The parameters of the expression can use modifiers and annotations , Such as final、@NonNull etc.

1.4 Functional interface

The functional interface is Java 8 For support Lambda Expression is a new invention , What’s mentioned above Lambda Syntax As mentioned in sort The sorting method is an example , A functional interface is used in this sort method , The prototype declaration of the function is as follows

public static <T> void sort(T[] a, Comparator<? super T> c)

In the above code Comparator<? Super T> It’s a functional interface ,? Super T or ? entends T from Java 5 Start introducing… When generics are supported , You have to understand , Let’s not talk about

What is a functional interface

1. Functional interfaces have two main features , It’s an interface , This interface has a unique extraction method , We call interfaces that satisfy these two characteristics functional interfaces , Speaking of this , I have to say that there is a specific implementation problem in the interface ~

2.Lambda An expression cannot exist without the target type , This directory type is a functional interface , Here is an example

String []datas = new String[] {"peng","zhao","li"};
Comparator<String> comp = (v1,v2) -> Integer.compare(v1.length(), v2.length());
Stream.of(datas).forEach(param -> {System.out.println(param);}); 

Lambda The expression is assigned to comp Function interface variables

3. Functional interfaces can be used @FunctionalInterface Annotate , After using this annotation , There are two main advantages , The compiler knows that this is a functional interface , Meet the requirements of functional expression , The other is generation Java Doc It is explicitly annotated

4. abnormal , If Lambda Expressions throw non runtime exceptions , The functional interface also needs to throw an exception , To put it bluntly , In a word , The functional interface is Lambda The target type of the expression

5. Functional interfaces can define public static Method , Think about it Java We provide Collection Interface , There is also a Collections Tools, etc , stay Java It’s just Collections The implementation of is transferred to the interface , But for backward compatibility , The old one Collection/Collections And so on

6. The functional interface can provide multiple image extraction methods , what ! It says there can only be one ? Yes , Multiple image extraction methods can be provided in the functional interface , But these methods limit the scope , Can only be Object Existing methods in types , Why do this ? Here to ignore , You can study it yourself

7. The default implementation of methods can be defined in functional interfaces , Here is Predicate Class code , Not only can it provide a default Realization , And it can provide multiple default To achieve? ,Java 8 It used to be OK ? My friends and I are shocked , This leads to the problem of multiple inheritance , Want to know Java 8 How to deal with it , Actually Easy, I’ll talk about it later ~

8. Why provide default Interface implementation ? Here’s a default implementation

default Predicate<T> or(Predicate<? super T> other) {
return (t) -> test(t) || other.test(t);

Java 8 This function is implemented by default in the interface , In fact, in a large number of programs, it violates the abstract feature of the interface , increase default The main reason for implementation is to consider compatibility and the cost of code change , for example , stay Java 8 To the iterator This interface adds a method , Then all classes that implement this interface need to implement this method once , that Java 8 Too many classes need to be changed , So in Iterator Add one to the interface default Realization , Then all classes that implement this interface have this implementation , To put it bluntly , It’s just a template design pattern

1.5 Method reference

Sometimes , The code we need to execute already exists in some classes , There’s no need for us to write Lambda expression , You can use this method directly , This is what we call method reference , As shown below , Code before using method reference

As shown below

Stream.of(datas).forEach(param -> {System.out.println(param);});

The code after using the method reference is as follows


The above example uses out object , The following example uses the static method reference of the class to sort the elements in the string array regardless of case

String []datas = new String[] {"peng","Zhao","li"};

Above are some typical examples of method references

Specific classification of method references


The first two of the above categories are in Lambda Expressions are equivalent in the sense of , Pass parameters to methods , Example above

System.out::println == x -> System.out.println(x)

The last category , The first parameter is the target of the method execution , The following example

String::compareToIgnoreCase == (x,y) -> x.compareToIgnoreCase(y)

And something like that super::instanceMethod This method is essentially the same as Object::instanceMethod similar

1.6 Construction method reference

Constructing method references is similar to method references , Except for one thing. , The method of constructing method reference is new! Here are two examples

Example 1 :

String str = "test";

Example 2 :

String []copyDatas = Stream.of(datas).toArray(String[]::new);
Stream.of(copyDatas).forEach(x -> System.out.println(x));

To sum up , There are two forms of constructor references


1.7 Lambda Expression scope

On the whole ,Lambda The variable scope of an expression is very similar to that of an inner class , It’s just that the conditions are relatively , Relax some of the previous internal class to refer to the variables of the external class , It has to be like this

final String[] datas = new String[] { "peng", "Zhao", "li" };
new Thread(new Runnable() {
public void run() {

Declare variable as final Type of , Now in Java 8 You can write code like this in

String []datas = new String[] {"peng","Zhao","li"};
new Thread(new Runnable() {
public void run() {

You can also write like this

new Thread(() -> System.out.println(datas)).start();

Anyway, how do you like to write , Just write about it ,I don’t Care it!

Looking at the two pieces of code above , Can find a significant difference , Namely Java 8 Middle inner class or Lambda Expression references to external variables are relaxed , It’s not mandatory to add final Keyword. , however Java 8 The variable is required to be effectively final

What is effectively final?

Effectively final Is a valid read-only variable , It means that this variable can be omitted final keyword , But this variable must be read-only , That is, once defined , You can’t modify it later , The following code will compile incorrectly

String []datas = new String[] {"peng","Zhao","li"};
datas = null;
new Thread(() -> System.out.println(datas)).start();

Java The inner classes in and Lambda It is also not allowed to modify variables in external classes in expressions , This is to avoid multithreading race condition

Lambda Variables and this keyword

Lambda The variable defined in is the same scope as the variable in the outer class , That is, the outer class defines ,Lambda You can’t repeat the definition , At the same time Lambda The expression uses this keyword , Pointing to an external class , You can practice it yourself , Here slightly

Unfinished to be written ….

Anger learning Java8 A series of :Lambda More articles on expressions

  1. Java8 series ( One ) Lambda expression

    Functional programming Introducing Lambda Before expression , First, we need to introduce another concept , Functional programming . Functional programming is a programming paradigm , That is, the methodology of how to write programs . Its core idea is to write the operation process as a series of nested function calls as much as possible , Pay attention to the …

  2. Java8 Learning notes —-Lambda expression ( turn )

    Java8 Learning notes —-Lambda expression   Tianjin 2014-03-24 16:43:30 Published in :ATA The home of         This paper mainly records my study Java8 History , It’s convenient for you to discuss and write your own notes together . Because I …

  3. Java8 New characteristics -Lambda What is an expression ?

    Catalog Preface Anonymous inner class Functional interface and Lambda Expression syntax Implement functional interfaces and use Lambda expression : therefore Lambda What is an expression ? Actual combat application summary Preface Java8 New characteristics -Lambda expression , good …

  4. Happy bytes -Java8 New characteristics -Lambda expression

    Last article we learned about Java8 New characteristics – Interface default method , Let’s talk next Java8 The new features Lambda expression . Lambda expression ( Also known as closures ), It allows us to pass a function as an argument to a method , Or think of the code itself as …

  5. Java8 New characteristics – Lambda expression – Basic knowledge

    A lambda expression is an unnamed block of code (or an unnamed function) with a list of formal param …

  6. JAVA8 Study —— Explain profound theories in simple language Lambda expression ( The learning process )

    JAVA8 Study — Explain profound theories in simple language Lambda expression ( The learning process ) lambda expression : Why do we use lambda expression stay JAVA in , We can’t pass a function as an argument to a method , You cannot declare a method that returns a function . stay …

  7. java8 New characteristics ——Lambda expression

    The above is a brief introduction java8 We need some new features , And advantages , Also for this study java8 New features set a learning direction , The next few articles will learn one by one according to the new features mentioned above . This article starts from java8 The more important of the new features Lambda The expression opens …

  8. java8 learning Lambda Expression depth and flow preliminary

    Lambda The expression goes deep : Last time [http://www.cnblogs.com/webor2006/p/8135873.html] Described in the Lambda The function of an expression is , It’s about this : As the red mark says , since …

  9. java8 learning Lambda Expression and functional interface

    about Java8 In fact, compared with the previous version, the content added is quite a lot , There’s a lot of it about Lambda The expression and Stream API, These two parts are closely combined and cannot be treated separately , But it can be used alone , So from learning …

Random recommendation

  1. Xcode modify storyboard size

    1: 2:

  2. 21.TFS File system building notes

    TFS File system building notes Reference address : https://github.com/alibaba/tfs/blob/master/INSTALL.md https://github.com/alibaba/t …

  3. 2.1 Sequence containers -vector

    vector 1) *   : Use vector Must contain vector The header file . Variable length dynamic arrays , Support random access , all STL Algorithms can be used to vector To operate . ** : The time to randomly access an element by subscript is a constant …

  4. C# – Things roll back

    This function depends on dbhelp.cs Portal :http://www.cnblogs.com/CyLee/p/5324652.html The starting point , Can’t put try In the sentence this.DbHelp.BeginTrans …

  5. C# Regular expressions and common regular expressions

    Metacharacters describe . spot Match any single character . For example, regular expressions r.t Match these strings :rat.rut.r t, But it doesn’t match root. $ Match line terminator . For example, regular expressions weasel$  Can match string “He’ …

  6. ASP.NET Use System.Web.Script.Serialization analysis JSON ( turn )

    JSON(JavaScript Object Notation) Is a lightweight data exchange format . Easy to read and write . At the same time, it is also easy for machine analysis and generation . It’s based on JavaScript Programming Langu …

  7. AI I’m sorry I still love you

    Allen iverson , I’m sorry , I still love you . Sometimes I don’t know what happened to me , It wasn’t until the end that I found out , I still love you . That day , I know you , It’s out of control . These days , Thank you , It seems that because of your influence, I have changed , A lot of it . It is only until now that I have found that …

  8. solve error104 connection reset by peer;socket error problem

    There are two reasons for this problem : 1. Because you visit the website too many times , So it’s forbidden by the webmaster . resolvent : 1. extend time.sleep Time 2. Setting agent 2. There is no such website at all .( Open the link and check !!!)

  9. lxml A concise tutorial

    I’m going to be a wechat crawler recently , Before I wrote a little thing, I just used regular to extract data , If you need more stable data extraction , Or use xpath Positioning elements are more reliable . Weekend is fine , From the perspective of reptiles python xml Related libraries . P …

  10. noip Hierarchical number theory ?

    TAT fast noip I started to contact number theory when I was young ( I really dare not learn ..) Let’s do some tidying up here ( It’s all definitions and stuff = =) Euclid :gcd(a,b)=gcd(b,a%b); See Encyclopedia for specific proof ? Expand Euclid : seek a*x+b*y …