Lambda表达式所有API整理-阿里云开发者社区

一、概念

二、内置函数式接口

Supplier接口

生产一个数据

Consumer接口

是消费一个数据

Function接口

java.util.function.Function<T,R>
根据一个类型的数据得到另一个类型的数据

Predicate接口

对某种类型的数据进行判断，从而得到一个boolean值结果

三、获取Stream流方式

1、通过Collection

1.1 Collection

ArrayList()

ArrayList<String> arrayList = new ArrayList<>();
arrayList.stream().forEach(System.out::println);

HashSet()

HashSet<String> hashSet = new HashSet<>();
hashSet.stream().forEach(System.out::println);

1.2 Map

先获取key/value的集合，再遍历

HashMap<String, String> hashMap = new HashMap<>();
hashMap.entrySet().stream().forEach(System.out::println);

2、静态方法

Stream<String>stram = Stream.of("aa","bb","cc")；

基本数据类型

会将整个数组，当成一个元素，进行处理

// 注意:基本数据类型的数组不行
int[] arr3 = {11, 22, 33};
Stream<int[]> stream9 = Stream.of(arr3);

四、常用方法

1、函数拼接方法

1.1 forEach

用来遍历流中的数据

特点

逐一处理
返回：void
种类：终结

//  带参数类型
one.stream().forEach((String s) -> {
    System.out.println(s);
});
//  可带处理逻辑方式
one.stream().forEach(s -> System.out.println(s));
//  简化版
one.stream().forEach(System.out::println);

其它API

//  以流内具有顺序进行循环(先将并行流合并后，按内部排序，再进行循环)
stream.forEachOrdered(System.out::println);

1.2 filter

于过滤数据，返回符合过滤条件的数据

特点

过滤
返回：Stream
种类：函数拼接

one.stream()
  .filter(s -> s.length() == 2)
    .forEach(System.out::println);

1.3 limit

对流进行截取，只取用前n个

特点

取用前几个
返回：Stream
种类：函数拼接

one.stream().limit(3);
one.stream()
  .limit(3)
    .forEach(System.out::println);

1.4 skip

跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

特点

跳过前几个
返回：Stream
种类：函数拼接

one.stream().skip(3);
one.stream()
  .skip(3)
    .forEach(System.out::println);

1.5 map

将流中的元素映射到另一个流中

特点

映射
返回：Stream
种类：函数拼接

one.stream().map(Integer::parseInt);
one.stream().map(Integer::parseInt).forEach(System.out::println);
one.stream()
  .map(s->Integer.parseInt(s));

其它API：

// 返回为Double流
.mapToDouble(c -> 1.0)
// 返回为Long流
.mapToLong(b -> 1L)
// 返回为Int流
.mapToInt(a -> 3)

1.6 flatMap

扁平化流处理

也就是将单个流，再进行条件筛选。1个流，分成2个流，或者0个流。

Stream<String> lines = Arrays.stream("18 +7,8,9".split(","));
//  ["18","+7","8","9"]
List<String> collect3 = lines
                            .flatMap(line -> Stream.of(line.split(" +")))
                            .collect(Collectors.toList());
//  []
List<Object> collect4 = lines
        .flatMap(s -> null)
        .collect(Collectors.toList());

其它的API

// 返回为Double流
.flatMapToDouble(c -> DoubleStream.of(1.0))
// 返回为Int流
.flatMapToInt(b -> IntStream.of(1))
// 返回为Long流
.flatMapToLong(a-> LongStream.of(2L))

1.7 sorted

将数据进行排序(自然/比较器)

特点

组合
返回：Stream
种类：函数拼接

//  自然排序
one.stream().sorted().forEach(System.out::println);
//  自定义排序(升序)
one.stream().map(Integer::parseInt).sorted((o1,o2)-> o1-o2);
//  自定义排序(降序)
one.stream().map(Integer::parseInt).sorted((o1,o2)-> o2-o1);

1.8 distinct

去除重复数据

组合
返回：Stream
种类：函数拼接

//  基本
strings.stream().distinct().forEach(System.out::println);

根据实体类字段

实体类

class Person{
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

代码

Stream.of(
        new Person("张三",10),
        new Person("李四",11),
        new Person("王五",12)
        ).distinct().forEach(System.out::println);

1.9 ***match

有3个相应API

//  元素是否全部满足条件
allMatch
//  元素是否任意有一个满足条件
anyMatch
//  元素是否全部不满足条件  
noneMatch

案例：

//  allMatch:元素是否全部满足条件
boolean result01 = one.stream().allMatch(a -> a.length() == 3);
//  anyMatch:元素是否任意有一个满足条件
boolean result02 = one.stream().anyMatch(d -> d.length() == 3);
//  noneMatch:元素是否全部不满足条件
boolean result03 = one.stream().noneMatch(c -> c.length() == 3);

1.10 find***

查找某些条件元素

内有2个API构成。结果为Option，依据Option语法执行

//  查找首个元素
findFirst()
//  查找任一元素
findAny()

案例：

//    查找首个元素（findFirst()）
Optional<String> first = one.stream().findFirst();
System.out.println("first="+first.get());
//  查找任一元素（findAny()）
Optional<String> any1 = one.stream().findAny();
System.out.println(any1.get());

1.11 max/min

获取最大值/最小值

//  最大值(max)
Optional<Integer> max = ints.stream().max((o1, o2) -> o1 - o2
ints.stream().max(Comparator.comparingInt(o -> o));
System.out.println("max: " + max.get());
//  最小值(min)
Optional<Integer> min = ints.stream().min((o1, o2) -> o1 - o2);
System.out.println("minx: " + min.get());

1.12 reduce

将所有数据归纳到一个数据

原理

第一次将默认赋值为x，取第一个值给y，进行操作。
第二次将第一次结果赋值给x，取第二个值给y，进行操作。

//  简单归纳
Integer reduce1 = one.stream().reduce(0, (a, b) -> a + b);
Integer reduce2 = one.stream().reduce(0, (c, d) -> Integer.sum(c, d));
Integer reduce3 = one.stream().reduce(0, Integer::sum);
//  自定义
Integer reduce = one.stream()
        .reduce(0, (x, y) -> {
            return x + y;
        });

1.13 concat

将2个流合并成1个流

Stream<String> stream01 = Stream.of("张三");
Stream<String> stream02 = Stream.of("李四");
Stream.concat(stream01, stream02).forEach(System.out::println);

2、终结方法

2.1 计数(count)

统计其中的元素个数

特点：

统计个数。
返回：long。
种类：终结。

one.stream().count()

2.2 输出打印(sout)

one.stream().forEach(System.out::println);

3、结果收集

3.1 收集到集合中(collect)

收集到List中

//  收集到List集合中
List<String> collect = Stream.of("aa", "bb", "cc").collect(Collectors.toList());

收集到Set中

//  收集到Set集合中
Set<String> set = Stream.of("aa", "bb", "cc").collect(Collectors.toSet());

收集到ArrayList中

//  收集到ArrayList中
ArrayList<String> arrayList = Stream.of("aa", "bb", "cc").collect(Collectors.toCollection(ArrayList::new));
String[] split = "1,23,456,7890".split(",");
ArrayList<Object> collect1 = Arrays.stream(split).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);

收集到HashSet中

//  收集到HashSet中
HashSet<String> hashSet = Stream.of("aa", "bb", "cc").collect(Collectors.toCollection(HashSet::new));

3.2 收集到数组中(toArray)

核心API：object[] Array();

Object[] objectArray = Stream.of("aa", "bb", "cc").toArray();
//  带类型
String[] strings = Stream.of("aa", "bb", "cc").toArray(String[]::new);
User[] users = Arrays.stream(split).toArray(User[]::new);

3.3 收集到字符串中(collect)

String[] split = "1,23,456,7890".split(",");
StringBuilder collect = Arrays.stream(split).collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);

4、Collectors中的方法

4.1 最大值

//  获取最大值
one.stream().collect(Collectors.maxBy((o1, o2) -> o1 - o2));

4.2 最小值

//  获取最小值
one.stream().collect(Collectors.minBy((o1, o2) -> o1 - o2));

4.3 求总和

//  求总和
one.stream().collect(Collectors.summingInt(Integer::intValue));

4.4 平均值

//  平均值
one.stream().collect(Collectors.averagingInt(Integer::intValue));

4.5 统计数量

//  统计数量
one.stream().collect(Collectors.counting());

4.6 进行单级分组(groupingBy)

根据某个字段分组

Map<Integer, List<Person>> listMap = Stream.of(
        new Person("张三", 10),
        new Person("李四", 11),
        new Person("王五", 12)
).collect(Collectors.groupingBy(Person::getAge));

自定义分组

实体类：

static class Person {
    private String name;
    private int age;
}

代码：

Map<String, List<Person>> map = Stream.of(
        new Person("张三", 10),
        new Person("李四", 11),
        new Person("王五", 12)
).collect(Collectors.groupingBy((s) -> {
    if (s.getAge() > 10) {
        return "满足";
    } else {
        return "不满足";
    }
}));
map.forEach((k,v)->{
    System.out.println(k+":"+v);
});

结果：

不满足:[Person{name='张三', age=10}]
满足:[Person{name='李四', age=11}, Person{name='王五', age=12}]

4.7 进行多级分组

实体类：

static class Person {
    private String name;
    private int age;
    private int socre;
}

代码：

Map<Integer, Map<String, List<Person>>> mapMap = Stream.of(
        new Person("张三", 10, 60),
        new Person("李四", 11, 80),
        new Person("王五", 12, 99)
).collect(Collectors.groupingBy(s -> s.getAge(), Collectors.groupingBy(s -> {
    if (s.getAge() > 10 && s.getSocre() > 60) {
        return "及格";
    } else if (s.getAge() < 10 && s.getSocre() < 60) {
        return "良好";
    } else {
        return "不及格";
    }
})));
mapMap.forEach((k, v) -> {
    System.out.println(k + "==:" + v);
});

结果：

10==:{不及格=[Person{name='张三', age=10, socre=60}]}
11==:{及格=[Person{name='李四', age=11, socre=80}]}
12==:{及格=[Person{name='王五', age=12, socre=99}]}

4.8 进行分区

实体类

static class Person {
    private String name;
    private int age;
    private int socre;
}

代码：

Stream<Person> stream = Stream.of(
        new Person("张三", 10, 60),
        new Person("李四", 11, 80),
        new Person("王五", 12, 99)
);
Map<Boolean, List<Person>> map01 = stream.collect(Collectors.partitioningBy(s -> s.getSocre() > 90));
map01.forEach((k, v) -> {
    System.out.println(k + "==:" + v);
});

结果：

false==:[Person{name='张三', age=10, socre=60}, Person{name='李四', age=11, socre=80}]
true==:[Person{name='王五', age=12, socre=99}]

4.9 进行拼接

为多个内容之间，插入数据。

//  B张三A李四A王五C
String collect1 = stream02.map(Person::getName).collect(Collectors.joining("A", "B", "C"));

五、全部方法

peek

改变Object中值，不改变String中值,与map类似

六、Optional

1、Optional.of()

赋值(初始化)

System.out.println("=======1、为空判断");
Optional<String> name = Optional.of("name");
System.out.println(name.isPresent());   //true

2、isPresent()

是否为空判断

System.out.println("=======2、isPresent()是否为空判断");
boolean name1 = Optional.ofNullable("name").filter(s -> "name".equals(s)).isPresent();  //true
System.out.println(name1);

3、.ifPresent()

不为空时操作

stream.findAny().ifPresent(System.out::println);

4、Optional.ofNullable(“ff”);

获取Optional(无：返回空Optional。有值：返回Option)

Optional<String> s = Optional.ofNullable("");

5、.get( )

获取值

Optional<String> ff = Optional.of("ff");
System.out.println(ff.get());

6、orElse()

为空时，赋值指定字符串

System.out.println("=======3、orElse: 为空时，取指字符串");
System.out.println(Optional.ofNullable(null).orElse("张三")); //张三

String result = Optional.ofNullable("ddd")
        .map(s -> "不为空执行业务流程。")
        .orElse("为空返回false");

//  为空，返回null对象
User user = userList.stream()
        .findFirst()
        .orElse(null);

7、orElseGet()

orElseGet: 为空时，取类中值

System.out.println("=======4、orElseGet: 为空时，取类中值");
StartConfig startConfig = new StartConfig();
startConfig.setTest01("test01");
System.out.println(Optional.ofNullable(null).orElseGet(startConfig::getTest01));    //test01

8、Optional.empty();

返回一个空的Optional

Optional<Object> empty = Optional.empty();

七、其它

1、注意事项

Stream只能操作一次。
Stream方法返回的是新的流。
Stream不调用终结方法，中间的操作不会执行。

2、参考地址

https://www.runoob.com/java/java8-streams.html

https://www.runoob.com/java/java8-streams.html

八、Xmind

CSDN

https://download.csdn.net/download/weixin_44624117/87670715

Lambda表达式所有API整理