做网站的前途线上宣传方式

12. 四大函数式接口

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口，可以有一些默认的方法

如：Runnable接口函数

1）Function 函数型接口

public class FunctionDemo {public static void main(String[] args) {Function<String, String> function = (str) -> {return str;};System.out.println(function.apply("aaaaaaaaaa"));}
}

2）Predicate 断定型接口

public class PredicateDemo {public static void main(String[] args) {Predicate<String> predicate = (str) -> {return str.isEmpty();};// falseSystem.out.println(predicate.test("aaa"));// trueSystem.out.println(predicate.test(""));}
}

3）Consummer 消费型接口

/*** 消费型接口 没有返回值！只有输入！*/
public class Demo3 {public static void main(String[] args) {Consumer<String> consumer = (str)->{System.out.println(str);};consumer.accept("abc");}
}

4）Suppier 供给型接口

/*** 供给型接口，只返回，不输入*/
public class Demo4 {public static void main(String[] args) {Supplier<String> supplier = ()->{return "1024";};System.out.println(supplier.get());}

13. Stream 流式计算

/*** Description：* 题目要求： 用一行代码实现* 1. Id 必须是偶数* 2.年龄必须大于23* 3. 用户名转为大写* 4. 用户名倒序* 5. 只能输出一个用户**/public class StreamDemo {public static void main(String[] args) {User u1 = new User(1, "a", 23);User u2 = new User(2, "b", 23);User u3 = new User(3, "c", 23);User u4 = new User(6, "d", 24);User u5 = new User(4, "e", 25);List<User> list = Arrays.asList(u1, u2, u3, u4, u5);//封装对象// lambda、链式编程、函数式接口、流式计算list.stream().filter(user -> {return user.getId()%2 == 0;}).filter(user -> {return user.getAge() > 23;}).map(user -> {return user.getName().toUpperCase();}).sorted((user1, user2) -> {return user2.compareTo(user1);}).limit(1).forEach(System.out::println);}
}

14. ForkJoin

ForkJoin 在JDK1.7，并行执行任务！提高效率~。在大数据量速率会更快！

大数据中：MapReduce 核心思想->把大任务拆分为小任务！

1）ForkJoin 特点： 工作窃取！

实现原理是：双端队列！从上面和下面都可以去拿到任务进行执行

2）如何使用ForkJoin?

• 1、通过ForkJoinPool来执行
• 2、计算任务 execute(ForkJoinTask task)
• 3、计算类要去继承ForkJoinTask；

理解API

ForkJoin 的计算类

package com.marchsoft.forkjoin;import java.util.concurrent.RecursiveTask;public class ForkJoinDemo extends RecursiveTask<Long> {private long star;private long end;/** 临界值 */private long temp = 1000000L;public ForkJoinDemo(long star, long end) {this.star = star;this.end = end;}/*** 计算方法* @return*/@Overrideprotected Long compute() {if ((end - star) < temp) {Long sum = 0L;for (Long i = star; i < end; i++) {sum += i;}return sum;}else {// 使用ForkJoin 分而治之 计算//1 . 计算平均值long middle = (star + end) / 2;ForkJoinDemo forkJoinDemo1 = new ForkJoinDemo(star, middle);// 拆分任务，把线程压入线程队列forkJoinDemo1.fork();ForkJoinDemo forkJoinDemo2 = new ForkJoinDemo(middle, end);forkJoinDemo2.fork();long taskSum = forkJoinDemo1.join() + forkJoinDemo2.join();return taskSum;}}
}

测试类

package com.marchsoft.forkjoin;import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;public class ForkJoinTest {private static final long SUM = 20_0000_0000;public static void main(String[] args) throws ExecutionException, InterruptedException {test1();test2();test3();}/*** 使用普通方法*/public static void test1() {long star = System.currentTimeMillis();long sum = 0L;for (long i = 1; i < SUM ; i++) {sum += i;}long end = System.currentTimeMillis();System.out.println(sum);System.out.println("时间：" + (end - star));System.out.println("----------------------");}/*** 使用ForkJoin 方法*/public static void test2() throws ExecutionException, InterruptedException {long star = System.currentTimeMillis();ForkJoinPool forkJoinPool = new ForkJoinPool();ForkJoinTask<Long> task = new ForkJoinDemo(0L, SUM);ForkJoinTask<Long> submit = forkJoinPool.submit(task);Long along = submit.get();System.out.println(along);long end = System.currentTimeMillis();System.out.println("时间：" + (end - star));System.out.println("-----------");}/*** 使用 Stream 流计算*/public static void test3() {long star = System.currentTimeMillis();long sum = LongStream.range(0L, 20_0000_0000L).parallel().reduce(0, Long::sum);System.out.println(sum);long end = System.currentTimeMillis();System.out.println("时间：" + (end - star));System.out.println("-----------");}
}

.parallel().reduce(0, Long::sum)使用一个并行流去计算整个计算，提高效率。

JUC并发编程-四大函数式接口、Stream 流式计算、ForkJoin并行执行任务 到此完结，笔者归纳、创作不易，大佬们给个3连再起飞吧