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

This article mainly explains "the detailed introduction of Java functional interface", interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Now let the editor to take you to learn the "detailed introduction of Java functional interface"!

Catalogue

Java- functional interface

1. Custom functional interface

1.1 Overview

1.2 format

1.3@FunctionalInterface comments

1.4 Custom functional Interface

two。 Functional programming

Delayed execution of 2.1Lambda

2.2 use Lambda as the parameter and return value

3. Common functional interface

3.1Supplier interface

3.2Consumer interface

3.3Predicate interface

3.4Function interface

Java- functional interface

1. Custom functional interface

1.1 Overview

In Java, a functional interface is an interface that has one and only one abstract method. * * of course, other methods can be included in the interface (default, static, private).

Functional interface, that is, the interface suitable for functional programming scenarios. The functional programming in Java is Lambda, so the functional interface is the interface that can be used by Lambda. Lambda in Java can be deduced smoothly only by ensuring that there is one and only one abstract method in the interface.

Note: "Syntax Sugar" refers to the code syntax that is more convenient to use, but the principle remains the same. For example, the for-each syntax used when traversing collections, in fact, the underlying implementation principle is still an iterator, which is called "syntax sugar". In terms of application, Lambda in Java can be regarded as the "syntax sugar" of anonymous inner classes, but the two are different in principle.

1.2 format

Just make sure there is one and only one abstract method in the interface:

Modifier interface interface name {public abstract return value type method name (optional parameter information); / / other non-abstract method content}

Because the public abstract of abstract methods in an interface can be omitted, defining a functional interface is simple:

Public interface MyFunctionalInterface {void myMethod ();} 1.3@FunctionalInterface comments

Similar to the use of @ Override annotations, a new annotation has been introduced in Java 8 specifically for functional interfaces: @ FunctionalInterface. This annotation can be used on the definition of an interface:

@ FunctionalInterfacepublic interface MyFunctionalInterface {void myMethod ();}

Once you use this annotation to define an interface, the compiler will force you to check that the interface does have one and only one abstract method, otherwise an error will be reported. It is important to note that even if you do not use this annotation, as long as it satisfies the definition of a functional interface, it is still a functional interface that is the same to use.

1.4 Custom functional Interface

For the MyFunctionalInterface functional interface that has just been defined, the typical usage scenario is as a parameter of the method:

Public class Hello {public static void show (MyFunctionalInterface p) {p.method1 ();} public static void main (String [] args) throws IOException {/ / calls the show method, whose parameter is an interface, so you can pass the interface's implementation class object show (new xppmzzz ()). / / call the show method, whose argument is an interface, so we can pass the interface's anonymous inner class show (new MyFunctionalInterface () {@ Override public void method1 () {System.out.println ("override abstract methods in the interface with anonymous inner classes");}}) / / call the show method. The parameter of the method is a functional interface, so we can use the Lambda expression show (()-> System.out.println ("overwrite persistent methods in the interface with Lamdba expressions");}} 2. Functional programming

Delayed execution of 2.1Lambda

After the code in some scenarios is executed, the results may not necessarily be used, resulting in a waste of performance. Lambda expressions, on the other hand, are deferred, which can be used as a solution to improve performance.

Log cases of wasted performance

Note: the log can help us quickly locate the problem and record the running process of the program, so as to monitor and optimize the project. A typical scenario is to conditionally use parameters, such as stitching log messages and printing them if the conditions are met:

Public class Demo01Logger {public static void main (String [] args) {String a = "little skin"; String b = "beauty"; String c = "ha"; log (1, a + b + c);} private static void log (int level, String s) {if (level = = 1) {System.out.println (s);}

There is a problem with this code: regardless of whether the level meets the requirements or not, as the second parameter of the log method, the three strings must first be concatenated and passed into the square method before the level judgment is made. If the level does not meet the requirements, then the string splicing operation will be done in vain, resulting in a waste of performance.

Note: SLF4J is a widely used logging framework. In order to solve the problem of wasted performance when logging, it is not recommended to concatenate the string first, but to pass some parts of the string into the method as variable parameters. String concatenation will be carried out only when the log level meets the requirements. For example: LOGGER.debug ("variable {} takes a value of {}." , "os", "macOS"), where curly braces {} are placeholders. If the log level requirements are met, the strings "os" and "macOS" will be concatenated to the position of the curly braces in turn; otherwise, string concatenation will not occur. This is also a viable solution, but Lambda can do better.

Experience a better way to write Lambda

Using Lambda requires a functional interface:

@ FunctionalInterfacepublic interface MessageBuilder {String buildMessage ();}

Then the log method is modified.

Public class Demo02LoggerLambda {public static void main (String [] args) {String a = "little skin"; String b = "beauty"; String c = "ha ha"; log (1, ()-> a + b + c) / * log (1, new MessageBuilder () {@ Override public String buildMessage () {return a + b + c;}}); * /} private static void log (int level, MessageBuilder builder) {if (level = = 1) {System.out.println (builder.buildMessage ()) }}}

In this way, three strings will be concatenated only if the level meets the requirements; otherwise, the three strings will not be concatenated.

Prove the delay of Lambda

Public class Demo02LoggerLambda {public static void main (String [] args) {String a = "little skin"; String b = "Meizi"; String c = "ha"; log (2, ()-> {System.out.println ("Lambda execution!") ; return a + b + c;}); / * log (2, new MessageBuilder () {@ Override public String buildMessage () {System.out.println ("Lambda execution!") ; return a + b + c;}}); * /} private static void log (int level, MessageBuilder builder) {if (level = = 1) {System.out.println (builder.buildMessage ());}

As you can see from the results, Lambda will not be executed if the level requirements are not met. So as to achieve the effect of saving performance.

Extension: the same effect can actually be achieved by using inner classes, except that the code operation is delayed to another object by calling a method. Whether or not to call its method is executed after the condition is determined.

2.2 use Lambda as the parameter and return value

Implementation principles aside, Lambda expressions in Java can be used as a substitute for anonymous inner classes. If the parameter of the method is a functional interface type, you can use an Lambda expression instead. To use a Lambda expression as a method parameter is to use a functional interface as a method parameter.

For example, the java.lang.Runnable interface is a functional interface, and if there is a startThread method that uses this interface as a parameter, then you can use Lambda to pass parameters. In fact, this situation is not fundamentally different from the constructor parameter of the Thread class is Runnable.

Public class demoRunnable {private static void startVThread (Runnable task) {new Thread (task). Start ();} public static void main (String [] args) {startVThread (()-> System.out.println ("Thread Task execution!")) ;}}

Similarly, if the return type of a method is a functional interface, you can directly return an Lambda expression. When you need a method to get an object of type java.util.Comparator interface as a sequencer, you can call this method to get it.

Public class mainCompartator {public static void main (String [] args) {String [] s = {"aaa", "bbbb", "c", "ppppp"}; System.out.println (Arrays.toString (s)); Arrays.sort (s, newComparator ()); System.out.println (Arrays.toString (s)) } private static Comparator newComparator () {return (a, b)-> b.length ()-a.length ();} 3. Common functional interface

JDK provides a large number of commonly used functional interfaces to enrich the typical usage scenarios of Lambda, which are mainly provided in the java.util.function package. Here are some of the simplest interfaces and examples of their use.

3.1Supplier interface

The java.util.function.Supplier interface contains only one method with no parameters: t get (). Used to get object data of the type specified by a generic parameter. Since this is a functional interface, this means that the corresponding Lambda expression needs to "provide" object data that conforms to the generic type.

Public class mainCompartator {public static void main (String [] args) {String a = "Hello"; String b = "World"; System.out.println (getString (()-> a + b)); / * System.out.println (getString (new Supplier () {@ Override public String get () {return a + b;}}) * /} private static String getString (Supplier funcation) {return funcation.get ();}

Topic: use the Supplier interface as the method parameter type, through the Lambda expression to find the maximum value in the int array. Tip: use the java.lang.Integer class for interface generics.

Public class mainCompartator {public static void main (String [] args) {int a [] = {322,24,3,35,3,53, 2544}; int maxA = getMax (()-> {int max = a [0]; for (int I: a) {max = Math.max (I, max);} return max;}) / * int maxA = getMax (new Supplier () {@ Override public Integer get () {int max = a [0]; for (int I: a) {max = Math.max (I, max);} return max }); * / System.out.println (maxA);} public static int getMax (Supplier sup) {return sup.get ();}} 3.2Consumer interface

The java.util.function.Consumer interface, in contrast to the Supplier interface, does not produce a piece of data, but consumes it, whose data type is determined by generics.

Abstract method: accept

The Consumer interface contains the abstract method void accept (T t), which means to consume a specified generic type of data. Basic uses such as:

Public class mainCompartator {public static void main (String [] args) {consumeString (s-> System.out.println (s)); / * consumeString (new Consumer () {@ Override public void accept (String s) {System.out.println (s);}}) * /} public static void consumeString (Consumer function) {function.accept ("Hello");}

Default method: andThen

If the parameters and return values of a method are all of type Consumer, then the effect can be achieved: when consuming data, first do an operation, and then do an operation to implement the combination. This method is the default method andThen in the Consumer interface. Here is the source code for JDK:

Default Consumer andThen (Consumer

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.