【Java】Java8的Lambda入门记录
简化定义匿名实现类
匿名实现类的传统方式
创建一个线程，需要实现Runnable接口，并实现public void run()方法，用传统的方式是这样的：
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello world");
}
}).start();
}
无参数、单语句方法体
用lambda可以简化成这样：
Runnable r = () -> System.out.print("hello world");
new Thread(r).start();
所以也可以这样：
public static void main(String[] args) {
new Thread(() -> System.out.println("hello world")).start();
}
所以，没参数、单语句的是这样的：
public class NoParameter {
public static void main(String[] args) {
MyInterface myInterface = () -> System.out.println("Hello World");
myInterface.methodA();
}
public interface MyInterface {
public void methodA();
}
}
无参数、多语句方法体
当然实现方法中有多条语句的情况下，应该是这样的：
public static void main(String[] args) {
new Thread(() -> {
System.out.println("1");
System.out.println("2");
}).start();
}
多参数、多语句方法体
多参数、多语句的是这样的：
public class MoreParameterMoreStatement {
public static void main(String[] args) {
MyInterface myInterface = (x, y) -> {
System.out.println("1st parameter : " + x);
System.out.println("2nd parameter : " + y);
};
myInterface.methodA(1, 5);
}
public interface MyInterface {
public void methodA(Integer x, Integer y);
}
}
流，Stream
这里的流，并非Java IO的流，是简化处理Java Collection的流。
过滤条件
public static void main(String[] args) {
List<String> list = Arrays.asList(new String[] {"1", "2", "3"});
Stream<String> stream = list.stream();
Predicate<String> predicate = s -> s != null && s.equals("1"); // 断言，Predicate。入参对象，出参boolean，用于判别一个对象
System.out.println("count -> " + stream.filter(predicate).count()); // 过滤并统计
}
简写：
/**
* 过滤
*/
@Test
public void predicateTestx1() {
List<String> list = Arrays.asList(new String[] {"1", "2", "3"});
List<String> resultList = list.stream().filter(s -> s != null && s.equals("1")).collect(Collectors.toList());
this.logger.info("resultList -> " + resultList);
}
Predicate有一个抽象方法：boolean test(T t);，入参是对象，出参是布尔值。
filter方法会调用test方法：
@Override
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
Objects.requireNonNull(predicate);
return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
StreamOpFlag.NOT_SIZED) {
@Override
Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
@Override
public void begin(long size) {
downstream.begin(-1);
}
@Override
public void accept(P_OUT u) {
if (predicate.test(u)) // 调用test()的逻辑
downstream.accept(u); // 加入下沉集合
}
};
}
};
}
转换为不同类型的集合
public static void main(String[] args) {
List<String> list = Arrays.asList(new String[] {"1", "2", "3"});
Stream<String> stream = list.stream();
Function<String, Integer> function = i -> Integer.valueOf(i); // Function<T, R>，转换成不同的类型
List<Integer> resultList = stream.map(function).collect(Collectors.toList());
System.out.println(resultList);
}
简写：
/**
* 转换类型
*/
@Test
public void functionTestx1() {
List<String> list = Arrays.asList(new String[] {"1", "2", "3"});
List<Integer> resultList = list.stream().map(i -> Integer.valueOf(i)).collect(Collectors.toList());
this.logger.info("resultList -> " + resultList);
}
合并多个集合
public static void main(String[] args) {
List<String> list1 = Arrays.asList(new String[] {"1", "2", "3"});
List<String> list2 = Arrays.asList(new String[] {"4", "5", "6"});
Function<List<String>, Stream<String>> function = list -> list.stream(); // List<String>转换为Stream<String>
List<String> allList = Stream.of(list1, list2).flatMap(function).collect(Collectors.toList()); // 合并多个集合
System.out.println(allList);
}
简写：
/**
* 转换类型
*/
@Test
public void mergeTestx1() {
List<String> list1 = Arrays.asList(new String[] {"1", "2", "3"});
List<String> list2 = Arrays.asList(new String[] {"4", "5", "6"});
// 这个不是我想要的结果
/*
List<List<String>> resultList1 = Stream.of(list1, list2).collect(Collectors.toList());
this.logger.info("resultList1 -> " + resultList1);
*/
List<String> resultList2 = Stream.of(list1, list2).flatMap(i -> i.stream()).collect(Collectors.toList());
this.logger.info("resultList2 -> " + resultList2);
}
获取集合最大、最小值
public static void main(String[] args) {
List<String> list = Arrays.asList(new String[] {"1", "2", "3"});
String max = list.stream().max(String::compareTo).get(); // 使用compareTo
String min = list.stream().min((x, y) -> x.compareTo(y)).get(); // 手动调用compareTo
System.out.println("max -> " + max);
System.out.println("min -> " + min);
}
分解操作，Reduce
/**
* 计算1-10总和
*/
public static void main(String[] args) throws Exception {
List<Integer> list = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); // 声明集合
BinaryOperator<Integer> binaryOperator = (x, y) -> {
int temp = x + y;
logger.info("temp sum -> {}", temp);
return temp;
};
int sum = list.stream().reduce(binaryOperator).get();
logger.info("sum -> {}", sum);
}
日志：
2017-09-17 21:53:33.529 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 3
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 6
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 10
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 15
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 21
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 28
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 36
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 45
2017-09-17 21:53:33.535 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 55
2017-09-17 21:53:33.536 [main] INFO c.n.exercise.stream.ReduceExercise - sum -> 55
并行操作
这里例子的关键在于parallel()设置了并行处理，具体对比与reduce的日志。
/**
* 计算1-10总和
*/
public static void main(String[] args) throws Exception {
List<Integer> list = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); // 声明集合
BinaryOperator<Integer> binaryOperator = (x, y) -> {
int temp = x + y;
logger.info("temp sum -> {}", temp);
return temp;
};
int sum = list.stream().parallel().reduce(binaryOperator).get();
logger.info("sum -> {}", sum);
}
日志：
2017-09-17 21:48:32.018 [ForkJoinPool.commonPool-worker-2] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 19
2017-09-17 21:48:32.018 [ForkJoinPool.commonPool-worker-1] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 9
2017-09-17 21:48:32.018 [main] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 13
2017-09-17 21:48:32.018 [ForkJoinPool.commonPool-worker-3] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 3
2017-09-17 21:48:32.023 [ForkJoinPool.commonPool-worker-2] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 27
2017-09-17 21:48:32.023 [ForkJoinPool.commonPool-worker-1] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 12
2017-09-17 21:48:32.023 [ForkJoinPool.commonPool-worker-2] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 40
2017-09-17 21:48:32.023 [ForkJoinPool.commonPool-worker-1] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 15
2017-09-17 21:48:32.023 [ForkJoinPool.commonPool-worker-1] INFO c.n.exercise.stream.ReduceExercise - temp sum -> 55
2017-09-17 21:48:32.024 [main] INFO c.n.exercise.stream.ReduceExercise - sum -> 55
两个集合的操作工具类：减去、交集、并集
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.assertj.core.util.Lists;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CollectionUtils {
private static Logger logger = LoggerFactory.getLogger(CollectionUtils.class);
/**
* 计算在list1存在，而在list2不存在的记录的集合
*/
public static <T> List<T> subtract(List<T> list1, List<T> list2) {
// 转换为Set
Set<T> set = list2.stream().collect(Collectors.toSet());
// 计算在list1存在，而在list2不存在的记录的集合
List<T> resultList = list1.stream().filter(i -> !set.contains(i)).collect(Collectors.toList());
return resultList;
}
/**
* 计算交集，在list1存在，并且在list2也存在的记录的集合
*/
public static <T> List<T> intersect(List<T> list1, List<T> list2) {
// 转换为Set
Set<T> set = list2.stream().collect(Collectors.toSet());
// 计算在list1存在，而在list2不存在的记录的集合
List<T> resultList = list1.stream().filter(i -> set.contains(i)).collect(Collectors.toList());
return resultList;
}
/**
* 计算并集，在list1和list2的记录合并，并且去重的集合
*/
public static <T> List<T> union(List<T> list1, List<T> list2) {
Set<T> set = Stream.of(list1, list2).flatMap(i -> i.stream()).collect(Collectors.toSet());
List<T> resultList = set.stream().collect(Collectors.toList());
return resultList;
}
@Test
public void subtractTest() {
List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
List<Integer> list2 = Lists.newArrayList(1, 5);
List<Integer> resultList = CollectionUtils.subtract(list1, list2);
this.logger.info("list1 -> {}", list1);
this.logger.info("resultList -> {}", resultList);
}
@Test
public void intersectTest() {
List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
List<Integer> list2 = Lists.newArrayList(1, 5);
List<Integer> resultList = CollectionUtils.intersect(list1, list2);
this.logger.info("list1 -> {}", list1);
this.logger.info("resultList -> {}", resultList);
}
@Test
public void unionTest() {
List<Integer> list1 = Lists.newArrayList(1, 2, 3, 4, 5);
List<Integer> list2 = Lists.newArrayList(1, 5, 6);
List<Integer> resultList = CollectionUtils.union(list1, list2);
this.logger.info("list1 -> {}", list1);
this.logger.info("resultList -> {}", resultList);
}
}
作者：Nick Huang 博客：http://www.cnblogs.com/nick-huang/
本博客为学习、笔记之用，以笔记形式记录学习的知识与感悟。学习过程中可能参考各种资料，如觉文中表述过分引用，请务必告知，以便迅速处理。如有错漏，不吝赐教。
如果本文对您有用，点赞或评论哦；如果您喜欢我的文章，请点击关注我哦~
本博客为学习、笔记之用，以笔记形式记录学习的知识与感悟。学习过程中可能参考各种资料，如觉文中表述过分引用，请务必告知，以便迅速处理。如有错漏，不吝赐教。
如果本文对您有用，点赞或评论哦；如果您喜欢我的文章，请点击关注我哦~
