java-进阶（函数式编程）

1.首先理解什么是lambda表达式？

简单来说，我们定义一个函数，往往要去想怎么调用，怎么创建对象，但是lambda表达式的思想是，我不用去管你怎么去做这件事情，我只关心你在做什么（有点绕口，多读两边）。我们只是为了达到目的，过程和形式并不重要。

2.代码体现？

以runnable接口为例：

　普通的写法（实现内部类接口）

 1 public class demo01runnable {
 2     public static void main(string[] args) {
 3         // 匿名内部类
 4         runnable task = new runnable() {
 5             @override
 6             public void run() { // 覆盖重写抽象方法
 7                 system.out.println("多线程任务执行！");
 8             }
 9         };
10         new thread(task).start(); // 启动线程
11     }
12 }

　lambda表达式写法

public class demo02lambdarunnable {
    public static void main(string[] args) {
        new thread(() -> system.out.println("多线程任务执行！")).start(); // 启动线程
    }
}

3.lambda优越性？

代码简洁，不用去写一大堆对象内部类，另一方面比较重要就是延时（会在下边举例）。

4.lambda的写法格式？

博主自己总结了一下，简单就是一个接口，只有一个抽象方法。

()->system.out.println("多线程任务执行！")看作是一个向上转型的对象就可以了，（）代表无参，当然是可以加参数的，参数以逗号隔开，

system.out.println("多线程任务执行！")是你实现的抽象方法，在这里也就是run方法。

至于返回值，要看你对抽象方法的定义，该返回什么就返回什么，和普通方法没有区别。

省略格式建议不要用，少两个括号感觉用处不大。

5.函数式接口？

函数式接口，即适用于函数式编程场景的接口。而java中的函数式编程体现就是lambda。

首先介绍一个注解@functionalinterface，他是放在接口类上的，作用是检查这个接口是不是只有一个抽象方法，当然也可以不写。

1 @functionalinterface
2 public interface myfunctionalinterface {
3 void mymethod();
4 }

下边再说延时执行

public class demo01logger {
private static void log(int level, string msg) {
if (level == 1) {
system.out.println(msg);
}
}
public static void main(string[] args) {
string msga = "hello";
string msgb = "world";
string msgc = "java";
log(1, msga + msgb + msgc);
}
}

我们会发现无论我的level等级是多少，字符串msga + msgb + msgc都会拼接，但是我们想想这样会不会造成一种资源的浪费当level=2时，我完全没必要去拼接字符串，因为字符串是不执行的。所以lambda的延时执行就体现出来了

@functionalinterface
public interface messagebuilder {
string buildmessage();
}

public class demo02loggerlambda {
private static void log(int level, messagebuilder builder) {
if (level == 1) {
system.out.println(builder.buildmessage());
}
}
public static void main(string[] args) {
string msga = "hello";
string msgb = "world";
string msgc = "java";
log(1, () ‐> msga + msgb + msgc );
}
}

所谓的延时，就是说在我传入接口对象参数时，我没有执行方法体，只有什么时候调用buildmessage（）这个方法的时候我才会执行。这就解决了资源浪费问题。

6.常用的函数式接口？

他们都是已经定义好抽象方法的接口

supplier接口：又称为供应商，不传入参数，但是会返回

java.util.function.supplier 接口仅包含一个无参的方法： t get() 。用来获取一个泛型参数指定类型的对 象数据。由于这是一个函数式接口，这也就意味着对应的lambda表达式需要“对外提供”一个符合泛型类型的对象 数据。

import java.util.function.supplier;
public class demo08supplier {
private static string getstring(supplier<string> function) {
return function.get();
}
public static void main(string[] args) {
string msga = "hello";
string msgb = "world";
system.out.println(getstring(() ‐> msga + msgb));
}
}

consumer接口：又称消费者，传入参数，但无返回

java.util.function.consumer 接口则正好与supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。

import java.util.function.consumer;
public class demo09consumer {
private static void consumestring(consumer<string> function) {
function.accept("hello");
}
public static void main(string[] args) {
consumestring(s ‐> system.out.println(s));
}
}

import java.util.function.consumer;
public class demo10consumerandthen {
private static void consumestring(consumer<string> one, consumer<string> two) {
one.andthen(two).accept("hello");
}
public static void main(string[] args) {
consumestring(
s ‐> system.out.println(s.touppercase()),
s ‐> system.out.println(s.tolowercase()));
}
}

predicate接口：有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果，这时可以使用 java.util.function.predicate 接口。 

import java.util.function.predicate;
public class demo15predicatetest {
private static void method(predicate<string> predicate) {
boolean verylong = predicate.test("helloworld");
system.out.println("字符串很长吗：" + verylong);
}
public static void main(string[] args) {
method(s ‐> s.length() > 5);
}
}

import java.util.function.predicate;
public class demo16predicateand {
private static void method(predicate<string> one, predicate<string> two) {
boolean isvalid = one.and(two).test("helloworld");
system.out.println("字符串符合要求吗：" + isvalid);
}
public static void main(string[] args) {
method(s ‐> s.contains("h"), s ‐> s.contains("w"));
}
}

function接口：接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件， 后者称为后置条件。

import java.util.function.function;
public class demo11functionapply {
private static void method(function<string, integer> function) {
int num = function.apply("10");
system.out.println(num + 20);
}
public static void main(string[] args) {
method(s ‐> integer.parseint(s));
}
}