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());
}
}