java函数式编程技巧汇总
Posted mask哥
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java函数式编程技巧汇总相关的知识,希望对你有一定的参考价值。
1.概念: 面向对象思想需要关注用什么对象完成什么事情。函数式编程思想-关注的是对数据进行了什么操作 2.优点: 代码简洁,开发快速(消灭大量代码嵌套;); 代码可读性搞; 大数据量下处理集合效率高;(易于并发编程) 3.Lambda表达式:让我们不关注什么是对象,关注对数据进行什么操作。本质是个匿名类。 可以多看看Swing里面对各种事件监听器的实现。 编写代码方法:先编写匿名内部类,然后mac下快捷键 cmd+1转换为lambda lambda表达式的省略规则: 参数类型可以省略 方法体只有一句代码时大括号return和唯一一句代码的分号可以省略 方法只有一个参数的小括号可以省略 4.stream流:使用函数式编程,用来对集合或数组链状流式进行操作,方便对集合或数组操作 使用stream注意事项: 惰性求值(如果没有终结操作,没有中间操作是不会得到执行) 流是一次性的(一旦一个流对象经过一个终结操作后,该流就不能被使用了) 不会影响原生数据(对流中进行数据处理,不会影响集合中元素) 5.optional:非空操作的判断,避免空指针 6.常见函数式接口: Consumer消费接口:对传入的参数进行消费 Function计算转换接口 Predicate:判断接口 Supplier:生产型接口,在get抽象方法中把创建好的对象返回 7.函数接口常用默认方法: and 相当于&&(与运算) or 相当于||(或运算) negate 相当于结果取反 ! 8.方法引用 基本格式: 类名或者对象名称::方法名 引用静态方法 类名::方法名 引用对象的实例方法 对象名::方法名 引用类的实例方法 类名::方法名 构造方法引用 类名::new 9.stream基本类型优化 stream提供了专门针对基本数据类型的方法。如:mapToInt,mapToLong,mapToDouble,flatMapToInt,flatMapToDouble 等 10.并行流:利用并行流提高操作效率。本质是把任务分配多线程处理。 利用parallel():串行流转换为并行流 利用peek():打印并行流日志 利用parallelStream():把集合对象直接转换为并行流对象
1.lambda表达式
package com.demo;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntPredicate;
public class Lambda1
public static int calculateNum(IntBinaryOperator operator)
int a=10;
int b=5;
return operator.applyAsInt(a,b);
public static void printNum(IntPredicate predicate)
int[] arr=1,2,3,4,5;
for(int i:arr)
if(predicate.test(i))
System.out.println(i);
public static void foreachArr(IntConsumer consumer)
int[] arr=1,2,3,4,5;
for(int i:arr)
consumer.accept(i);
public static void main(String[] args)
// new Thread(() -> System.out.println("#########")).start();
// int sum=calculateNum((left, right) -> left+right);
// System.out.println(sum);
//
// printNum(value -> value%2==0);
foreachArr(value -> System.out.println(value));
2. stream操作
package com.demo;
import java.util.*;
import java.util.function.*;
import java.util.stream.Stream;
import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;
public class Stream1
public static void main(String[] args)
List<Integer> aa = new ArrayList<>();
aa.add(3);
aa.add(8);
aa.add(3);
aa.stream()
.distinct().filter(integer -> integer > 4).forEach(integer -> System.out.println("consuer:" + integer));
//不大于 negate()
aa.stream().filter(((Predicate<Integer>) input -> input > 4).negate()).forEach(input -> System.out.println("不大于4的数据:" + input));
//parallelStream():把集合对象直接转换为并行流对象,提高执行效率
aa.parallelStream().filter(((Predicate<Integer>) input -> input > 4).negate()).forEach(input -> System.out.println("不大于4的数据:" + input));
//mapToInt 优化执行效率
aa.stream().mapToInt(value -> value).map(operand -> operand + 10).forEach(System.out::println);
//单列集合
Stream<Integer> stream = aa.stream();
stream.forEach(integer -> System.out.println(integer));
//双列集合:转换成单列集合后再创建
HashMap<String, Integer> m = new HashMap<>();
m.put("小新", 19);
m.put("小新2", 139);
m.put("小新4", 169);
Stream<Map.Entry<String, Integer>> stream1 = m.entrySet().stream();
System.out.println("map size:" + stream1.count());
Set<Map.Entry<String, Integer>> entries = m.entrySet();
Stream<Map.Entry<String, Integer>> stream2 = entries.stream();
stream2.filter(stringIntegerEntry -> stringIntegerEntry.getValue() > 20).forEach(mm -> System.out.println(mm.getKey() + ":" + mm.getValue()));
//最大值
List<Integer> kk = Stream.of(aa, asList(6, 1, 3)).flatMap((Function<List<Integer>, Stream<Integer>>) integers -> integers.stream()).collect(toList());
System.out.println("max:" + kk.stream().max((o1, o2) -> o1 - o2).get());
//count:获取元素中的个数
ArrayList<String> strings = new ArrayList<>();
strings.add("b");
strings.add("kk");
System.out.println("count:" + strings.stream().count());
//collect把流中元素转换成集合
List<String> collect = strings.stream().collect(toList());
System.out.println("collect:" + collect);
//reduce对元素求和
System.out.println("合计:" + Stream.of(1, 23, 4).reduce((integer, integer2) -> integer + integer2).get());
//map 对流中元素进行计算或者转换
aa.stream().sorted((o1, o2) ->
return o2 - o1; //确定升降级
).map(new Function<Integer, String>()
@Override
public String apply(Integer integer)
return integer.toString() + "ok";
).forEach(s -> System.out.println("s:" + s));
//limit设置流的最大长度,超出抛出异常
aa.stream().limit(2).forEach(new Consumer<Integer>()
@Override
public void accept(Integer integer)
System.out.println("in:" + integer);
);
//跳过流中的n个元素,返回剩下的元素
aa.stream().skip(2).forEach(new Consumer<Integer>()
@Override
public void accept(Integer integer)
System.out.println("i:" + integer);
);
//anyMatch 任意匹配的返回true
System.out.println("anymatch result:" + aa.stream().anyMatch(new Predicate<Integer>()
@Override
public boolean test(Integer integer)
return integer > 4;
));
//allMatch:判断是否都符合匹配条件,符合返回true
System.out.println("allMatch result:" + aa.stream().allMatch(new Predicate<Integer>()
@Override
public boolean test(Integer integer)
return integer > 4;
));
//noneMatch:判断流中元素都不符合匹配条件。如果都不符合返回true
System.out.println("noneMatch result:" + aa.stream().noneMatch(new Predicate<Integer>()
@Override
public boolean test(Integer integer)
return integer > 9;
));
//findAny:获取流中任意一个元素。该方法没办法保证获取的一定是流中第一个元素
System.out.println("findAny result:" + aa.stream().findAny().get());
//findFirst:获取流中第一个元素
System.out.println("findFirst:" + aa.stream().findFirst().get());
//reduce求最大值
System.out.println("reduce求最大值:" + aa.stream().reduce(Integer.MIN_VALUE, new BinaryOperator<Integer>()
@Override
public Integer apply(Integer result, Integer ele)
return result < ele ? ele : result;
));
//reduce求和
System.out.println("reduce:求和:" + aa.stream().reduce(0, new BinaryOperator<Integer>()
@Override
public Integer apply(Integer result, Integer ele)
return result + ele;
));
//optional非空判断
Integer ara = null;
Optional<Integer> ara1 = Optional.ofNullable(ara);
ara1.ifPresent(value ->
System.out.println(value);
);
//null输出默认值
System.out.println(ara1.orElse(111));
Stream<Integer> stream3 = Stream.of(1, 3, 5, 6, 10);
System.out.println("串行流操作:" + stream3.filter(num -> num > 5).reduce((reuslt, input) -> reuslt + input).get());
Stream<Integer> stream4 = Stream.of(1, 3, 5, 6, 10);
System.out.println("并行流操作:" + stream4.parallel().peek(num -> System.out.println("打印执行日志" + num + Thread.currentThread().getName())).filter(num -> num > 5).reduce((reuslt, input) -> reuslt + input).get());
以上是关于java函数式编程技巧汇总的主要内容,如果未能解决你的问题,请参考以下文章
Kotlin函数式编程 ③ ( 早集合与惰性集合 | 惰性集合-序列 | generateSequence 序列创建函数 | 序列代码示例 | take 扩展函数分析 )
Kotlin函数式编程 ③ ( 早集合与惰性集合 | 惰性集合-序列 | generateSequence 序列创建函数 | 序列代码示例 | take 扩展函数分析 )