大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
Q：最近接触到Stream流式编程遇到了一些错误，故做一次总结复习用。
一、λ表达式
通常我们会用一个类实现接口，然后构造对象作为参数传入，也可以使用匿名类，用λ表达式可以简化匿名类的编写，用例如下。
class Worker implements Runnable {
@Override
public void run() {
// TODO: 2019/6/2
}
}
Thread t = new Thread(new Runnable() {
@Override
public void run() {
// TODO: 2019/6/2
}
});
Thread t1 = new Thread(new Worker());
Thread t2 = new Thread(()->{
// TODO: 2019/6/2
});
λ表达式语法：
（String str,...）-＞{ }
()->{}
()-> System.out.println();
表达式中引用的外部的变量,必须是 最终变量 final
List<Integer> list = new LinkedList<>();
list.forEach(System.out::println);//这里是类的静态方法，也可以是Object::instanceMethod，也可以是Class::instanceMethod
// System.out::println== x-＞sout（x） Math::pow == Math.pow(x,y)
也可以是 Class::new
List<String> list = Arrays.asList("zhangsan","lisi");
List<Person> res= list.stream().map(Person::new).collect(Collectors.toList());
System.out.println(res);
// [zhangsan, lisi]
list.forEach(e-> System.out.println(e)); //只有一行可以省略花括号
Comparator<String> c =（f,fs）-＞f.length-fs.length; //可推导出f fs 必然是字符串等价于（String f, String fs）则可以省略方法参数的类型
其中Comparator如下:
public interface Comparator<T> {
int compare(T o1, T o2);
}
函数式接口
public static <T> void sort(T[] a, Comparator<? super T> c)
Integer[] array = new Integer[]{3,2,1};
Arrays.sort(array,(o1, o2) -> o1-o2);
//sout 1,2,3
@FunctionalInterface
public interface BiFunction<T, U, R>{
R apply(T t, U u) //输入T、U 返回 R类型
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after); //输入T、U 返回 R类型
return (T t, U u) -> after.apply(apply(t, u)); //然后将R传入作为参数传入Function<? super R, ? extends V> after
}; //对于Function而言，传入值为V的子类，返回值是R的一种父类
}
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
常见函数式接口：
Stream 解析
stream of elements -----> filter ->sorted-> map -> collect
其中 Stream<T> filter(Predicate<? super T> predicate); 返回值为Stream
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t) ; //校验是否满足条件
default Predicate<T> and(Predicate<? super T> other) { //且
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {//校验是否不满足条件
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
//sorted
Stream<T> sorted(); //元素自身需要实现 Comparable
Stream<T> sorted(Comparator<? super T> comparator);
// map 将集合中的元素转换为另外一种类型 ，同时返回的为 Stream
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
----------------------------------------------------#### //reduce
Optional<T> reduce(BinaryOperator<T> accumulator);//流的第一个元素与第二个进行操作返回相同类型作为第一个参数再次传入
//如(x,y)->x+u 流为：1，2，3，... 则(1,2)->3 (3,3)->6 .......
public interface BinaryOperator<T> extends BiFunction<T,T,T> { //BiFunction<T,T,T> T apply(T t, T u);
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
}
//用法
List<Integer> list = Arrays.asList(3, 2, 4, 1, 5, 6, 7); ///10
System.out.println(list.stream().reduce((a, b) -> a+ b).get()); //求和 T apply(T t, T u);
List<String> list = Arrays.asList("zhangsan","lisi","wangwu"); //拼接
System.out.println(list.stream().filter(e->e.length()>1)
.reduce((s, s2) -> s+","+s2).get());
BinaryOperator<Integer> bi = BinaryOperator.minBy(Comparator.naturalOrder());
System.out.println(bi.apply(2, 3)); //sout 2
--------------------------------------------------
T reduce(T identity, BinaryOperator<T> accumulator);//这里同上，只是给出了一个初始值
<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner); //BiFunction<T, U, R>
//这里U可以是不同类型，例如 是一个容器，可以存放流中处理的值
//第二个表达式中 输入为 T，U返回值为U 即该方法第一个参数会作为参数传入，第三个参数只有在并行的时候才有用，合并结果集
list.stream().reduce(new ArrayList<Integer>(), new BiFunction<ArrayList<Integer>, Integer, ArrayList<Integer>>() {
@Override
public ArrayList<Integer> apply(ArrayList<Integer> integers, Integer integer) {
integers.add(integer);
return integers;
}
}, new BinaryOperator<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> apply(ArrayList<Integer> strings, ArrayList<Integer> strings2) {
return strings;
}
});
----------------------------------------------------------
collect
<R, A> R collect(Collector<? super T, A, R> collector);
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/191829.html原文链接：https://javaforall.net
![记一次使用策略模式优化代码的经历[通俗易懂]](https://javaforall.net/wp-content/uploads/2020/11/2020110817443450-480x300.jpg)
