Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "how to master Lambda in Java". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Method type

The method has been a first-class citizen since Java 8. According to the standard definition, a first-class citizen in a programming language is an entity with the following functions

Can be passed as a parameter, can be assigned to a variable as the return value of the method.

In Java, every parameter, return value, or variable is typed, so every first-class citizen must be typed. One type in Java can be one of the following:

A built-in type (such as int or double), a class (such as ArrayList), an interface (such as Iterable)

The method defines the type through the interface. They do not implicitly implement a specific interface, but if necessary, if a method conforms to an interface, the Java compiler implicitly checks it during compilation. Take an example to illustrate:

Class LambdaMap {static void oneStringArgumentMethod (String arg) {System.out.println (arg);}}

Related to the type of the oneStringArgumentMethod function is that its function is static, the return type is void, and it accepts an argument of type String. A static function conforms to the interface that contains an apply function, and the signature of the apply function corresponds to the signature of the static function.

The interface corresponding to the oneStringArgumentMethod function must therefore meet the following criteria.

It must contain a function named apply. The function return type must be void. The function must accept the parameters of an object to which the String type can be converted.

Of the interfaces that meet this standard, the following is the clearest:

Interface OneStringArgumentInterface {void apply (String arg);}

Using this interface, a function can be assigned to a variable:

OneStringArgumentInterface meth = LambdaMap::oneStringArgumentMethod

Using an interface as a type in this way, a function can be assigned to a variable, pass parameters, and return from the function:

Static OneStringArgumentInterface getWriter () {return LambdaMap::oneStringArgumentMethod;} static void write (OneStringArgumentInterface writer, String msg) {writer.apply (msg);}

The final function is a first-class citizen.

Generic function type

Just like using collections, generics add a lot of functionality and flexibility to function types. Implement a functional algorithm without considering type-related information, and generic function types make it possible. This feature is used below in the implementation of the map function.

A generic version of OneStringArgumentInterface is provided here:

Interface OneArgumentInterface {void apply (T arg);}

The OneStringArgumentInterface function can be assigned to it:

OneArgumentInterface meth = LambdaMap::oneStringArgumentMethod

By using generic function types, it can now implement algorithms in a general way, just as it does in collections:

Static void applyArgument (OneArgumentInterface meth, T arg) {meth.apply (arg);}

The above function is useless, but it can at least suggest an idea of how support for a function as a member of the first class can result in very concise and flexible code:

ApplyArgument (Lambda::oneStringArgumentMethod, "X")

Implement map

Among the many higher-order functions, map is the most classical. The first argument to map is a function, which takes an argument and returns a value; the second argument is a list of values. Map uses the passed-in function to process each item in the values list and then returns a new values list. The following Python code snippet is a good illustration of the use of map:

> map (math.sqrt, [1,4,9,16]) [1.0,2.0,3.0,4.0]

The Java implementation of this function is given later in this section. Java 8 already provides this function through Stream. Because it is primarily for educational purposes, the implementation given in this section is deliberately kept simple and is limited to List objects.

Unlike Python, the type of the first parameter of map must first be considered in Java: a method that can take a parameter and return a value. The type of parameter and the type of return value can be different. The following API meets this expectation. Obviously, I represents the parameter (input parameter) and O indicates the return value (output parameter):

Interface MapFunction {O apply (I in);}

The implementation of the generic map method has become surprisingly straightforward:

Static List map (MapFunction func, List input) {List out = new ArrayList (); for (I in: input) {out.add (func.apply (in));} return out;}

1. Create a new return value list out (used to save O-type objects).

two。 Each item in the list is processed by traversing the input,func and the return value is added to the out.

3. Return to out.

The following is an example of actually using the map method:

MapFunction func = Math::sqrt;List output = map (func, Arrays.asList (1., 4., 9., 16.); System.out.println (output)

Driven by Python one-liner, it can be expressed in a more concise way:

System.out.println (map (Math::sqrt, Arrays.asList (1., 4., 9., 16.))

Java is not Python... after all.

Here comes Lambdas!

Readers may notice that Lambdas has not been mentioned yet. This is due to the use of a "bottom-up" approach to description, and now that the foundation is basically established, Lambdas will be described in subsequent chapters.

The following use case serves as the basis: a list of type double, which represents the radius, and then gets a list representing the area of the circle. The map method is prepared in advance for this task. The formula for calculating the area of a circle is well known:

A   =   R2 π

The method of applying this formula is easy to implement:

Static Double circleArea (Double radius) {return Math.pow (radius, 2) * Math.PI;}

This method can now be used as the first parameter of the map method:

System.out.println (map (LambdaMap::circleArea,Arrays.asList (1.,4., 9., 16.))

If the circleArea method only needs this once, there is no reason to mess up the class interface by him, or to separate the implementation from where it is actually used. The best practice is to use anonymous inner classes. As you can see, instantiating an anonymous inner class that implements the MapFunction interface accomplishes this task very well:

System.out.println (map (new MapFunction () {public Double apply (Double radius) {return Math.sqrt (radius) * Math.PI;}}, Arrays.asList (1,2.3,4.)

This looks beautiful, but many people will think that functional solutions are clearer and more readable:

List out = new ArrayList (); for (Double radius: Arrays.asList (1, 2, 3, 4.)) {out.add (Math.sqrt (radius) * Math.PI);} System.out.println (out)

So far, the last thing is to use Lambda expressions. Readers should notice how Lambda replaces the anonymous classes mentioned above:

System.out.println (map (radius-> {return Math.sqrt (radius) * Math.PI;}, Arrays.asList (1.2,3.4.)

This seems straightforward-notice how Lambda expressions default any explicit type information. There is no explicit template instantiation, no method signature.

The Lambda expression consists of two parts that are separated by->. The first part is the parameter list, and the second part is the actual implementation.

Lambda expressions do exactly the same thing as anonymous inner classes, but it abandons a lot of boilerplate code that the compiler can infer automatically. Let's compare the two approaches again, and then analyze what work the compiler saves for developers.

MapFunction functionLambda = radius-> Math.sqrt (radius) * Math.PI;MapFunction functionClass = new MapFunction () {public Double apply (Double radius) {return Math.sqrt (radius) * Math.PI;}}

For the Lambda implementation, there is only one expression, and the return statement and curly braces can be omitted. This makes the code shorter. The return type of the Lambda expression is inferred from the Lambda implementation. I'm not entirely sure about the parameter type, but I think it's necessary to infer the parameter type from the context of the Lambda expression. Finally, the compiler must check whether the return value type matches the context of Lambda and whether the parameter type matches the Lambda implementation.

All of this can be done during compilation, with no runtime overhead at all.

This is the end of the content of "how to master Lambda in Java". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.