java8 新特性快速入门

最新推荐文章于 2022-07-11 21:33:44 发布

KirioYoLo

最新推荐文章于 2022-07-11 21:33:44 发布

阅读量331

点赞数 1

分类专栏： Java 文章标签： java stream java8

本文链接：https://blog.csdn.net/u012154840/article/details/105919382

版权

Java 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

利用java8新特性，可以用简洁高效的代码来实现一些数据处理。

一、Stream流简易操作demo

定义1个Apple对象：

public class Apple {
    private Integer id;
    private String name;
    private BigDecimal money;
    private Integer num;
    public Apple(Integer id, String name, BigDecimal money, Integer num) {
        this.id = id;
        this.name = name;
        this.money = money;
        this.num = num;
    }
}

添加一些测试数据：

List<Apple> appleList = new ArrayList<>();//存放apple对象集合
 
Apple apple1 =  new Apple(1,"苹果1",new BigDecimal("3.25"),10);
Apple apple12 = new Apple(1,"苹果2",new BigDecimal("1.35"),20);
Apple apple2 =  new Apple(2,"香蕉",new BigDecimal("2.89"),30);
Apple apple3 =  new Apple(3,"荔枝",new BigDecimal("9.99"),40);
 
appleList.add(apple1);
appleList.add(apple12);
appleList.add(apple2);
appleList.add(apple3);

1、分组

List里面的对象元素，以某个属性来分组，例如，以id分组，将id相同的放在一起：

//List 以ID分组 Map<Integer,List<Apple>>
Map<Integer, List<Apple>> groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));
 
System.err.println("groupBy:"+groupBy);
{1=[Apple{id=1, name='苹果1', money=3.25, num=10}, Apple{id=1, name='苹果2', money=1.35, num=20}], 2=[Apple{id=2, name='香蕉', money=2.89, num=30}], 3=[Apple{id=3, name='荔枝', money=9.99, num=40}]}

2、List转Map

id为key，apple对象为value，可以这么做：

/**
 * List -> Map
 * 需要注意的是：
 * toMap 如果集合对象有重复的key，会报错Duplicate key ....
 *  apple1,apple12的id都为1。
 *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
 */
Map<Integer, Apple> appleMap = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a,(k1,k2)->k1));

打印appleMap

{1=Apple{id=1, name='苹果1', money=3.25, num=10}, 2=Apple{id=2, name='香蕉', money=2.89, num=30}, 3=Apple{id=3, name='荔枝', money=9.99, num=40}}

3、过滤Filter

从集合中过滤出来符合条件的元素：

//过滤出符合条件的数据
List<Apple> filterList = appleList.stream().filter(a -> a.getName().equals("香蕉")).collect(Collectors.toList());
 
System.err.println("filterList:"+filterList);
[Apple{id=2, name='香蕉', money=2.89, num=30}]

4、求和

将集合中的数据按照某个属性求和:

//计算 总金额
BigDecimal totalMoney = appleList.stream().map(Apple::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
System.err.println("totalMoney:"+totalMoney);  //totalMoney:17.48

5、查找流中最大最小值

Collectors.maxBy 和 Collectors.minBy 来计算流中的最大或最小值。

Optional<Dish> maxDish = Dish.menu.stream().
      collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
maxDish.ifPresent(System.out::println);
 
Optional<Dish> minDish = Dish.menu.stream().
      collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
minDish.ifPresent(System.out::println);

6、去重

import static java.util.Comparator.comparingLong;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;
 
// 根据id去重
     List<Person> unique = appleList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(comparingLong(Apple::getId))), ArrayList::new)
        );

工厂方法	返回类型	作用
toList	List<T>	把流中所有项目收集到一个 List
toSet	Set<T>	把流中所有项目收集到一个 Set，删除重复项
toCollection	Collection<T>	把流中所有项目收集到给定的供应源创建的集合menuStream.collect(toCollection(), ArrayList::new)
counting	Long	计算流中元素的个数
sumInt	Integer	对流中项目的一个整数属性求和
averagingInt	Double	计算流中项目 Integer 属性的平均值
summarizingInt	IntSummaryStatistics	收集关于流中项目 Integer 属性的统计值，例如最大、最小、总和与平均值
joining	String	连接对流中每个项目调用 toString 方法所生成的字符串collect(joining(", "))
maxBy	Optional<T>	一个包裹了流中按照给定比较器选出的最大元素的 Optional，或如果流为空则为 Optional.empty()
minBy	Optional<T>	一个包裹了流中按照给定比较器选出的最小元素的 Optional，或如果流为空则为 Optional.empty()
reducing	归约操作产生的类型	从一个作为累加器的初始值开始，利用 BinaryOperator 与流中的元素逐个结合，从而将流归约为单个值累加int totalCalories = menuStream.collect(reducing(0, Dish::getCalories, Integer::sum));
collectingAndThen	转换函数返回的类型	包裹另一个收集器，对其结果应用转换函数int howManyDishes = menuStream.collect(collectingAndThen(toList(), List::size))
groupingBy	Map<K, List<T>>	根据项目的一个属性的值对流中的项目作问组，并将属性值作为结果 Map 的键
partitioningBy	Map<Boolean,List<T>>	根据对流中每个项目应用谓词的结果来对项目进行分区

二、Stream流进阶操作

定义Dish类

public class Dish { 
 private final String name; 
 private final boolean vegetarian; 
 private final int calories; 
 private final Type type; 
 public Dish(String name, boolean vegetarian, int calories, Type type) { 
 this.name = name; 
 this.vegetarian = vegetarian; 
 this.calories = calories; 
 this.type = type; 
 } 
 public String getName() { 
 return name; 
 } 
 public boolean isVegetarian() { 
 return vegetarian; 
 } 
 public int getCalories() { 
 return calories; 
 } 
 public Type getType() { 
 return type; 
 } 
 @Override 
 public String toString() { 
 return name; 
 }
 public enum Type { MEAT, FISH, OTHER } 
 }

1、筛选满足某些条件的前N条数据

import static java.util.stream.Collectors.toList; 
List<String> threeHighCaloricDishNames = 
 menu.stream() 
 .filter(d -> d.getCalories() > 300)
 .map(Dish::getName)
 .limit(3) 
 .collect(toList());
System.out.println(threeHighCaloricDishNames);

在本例中，我们先是对 menu 调用 stream 方法，由菜单得到一个流。数据源是菜肴列表（菜单），它给流提供一个元素序列。接下来，对流应用一系列数据处理操作： filter 、 map 、 limit 和collect 。除了 collect 之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线，于是就可以看作对源的一个查询。最后， collect 操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的不是流，在这里是一个List ）。在调用 collect 之前，没有任何结果产生，实际上根本就没有从menu 里选择元素。你可以这么理解：链中的方法调用都在排队等待，直到调用collect。

2、用谓词筛选

Streams 接口支持 filter 方法（你现在应该很熟悉了）。该操作会接受一个谓词（一个返回 boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。例如，你可以像图所示的这样，筛选出所有素菜，创建一张素食菜单：

3、跳过元素

流还支持 skip(n) 方法，返回一个扔掉了前 n 个元素的流。如果流中元素不足 n 个，则返回一个空流。请注意，limit(n) 和 skip(n) 是互补的！例如，下面的代码将跳过超过 300 卡路里的头两道菜，并返回剩下的。图展示了这个查询。

List<Dish> dishes = menu.stream()
.filter(d -> d.getCalories() > 300)
.skip(2)
.collect(toList());

4、流的扁平化

对于一张单词表，如何返回一张列表，列出里面各不相同的字符呢？例如，给定单词列表 ["Hello","World"]，你想要返回列表 ["H","e","l", "o","W","r","d"] 。这个方法的问题在于，传递给map方法的Lambda为每个单词返回了一个String[]（String

列表）。因此， map 返回的流实际上是 Stream<String[]> 类型的。你真正想要的是用 Stream<String>来表示一个字符流。

List<String> uniqueCharacters = 
 words.stream() 
 .map(w -> w.split("")) 
 .flatMap(Arrays::stream) 
 .distinct() 
 .collect(Collectors.toList());

使用 flatMap 方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream) 时生成的单个流都被合并起来，即扁平化为一个流

一言以蔽之， flatmap 方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流。

5、对流中每一个元素应用函数

流支持 map 方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）。

例如，下面的代码把方法引用 Dish::getName 传给了 map 方法，来提取流中菜肴的名称：

List<String> dishNames = menu.stream()
.map(Dish::getName)
.collect(toList());

因为getName方法返回一个String，所以map方法输出的流的类型就是Stream<String>。让我们看一个稍微不同的例子来巩固一下对map的理解。给定一个单词列表，你想要返回另一个列表，显示每个单词中有几个字母。怎么做呢？你需要对列表中的每个元素应用一个函数。这听起来正好该用map方法去做！应用的函数应该接受一个单词，并返回其长度。你可以像下面这样，给map传递一个方法引用String::length来解决这个问题：

List<String> words = Arrays.asList("Java 8", "Lambdas", "In", "Action");
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(toList());

现在让我们回到提取菜名的例子。如果你要找出每道菜的名称有多长，怎么做？你可以像下面这样，再链接上一个map ：

List<Integer> dishNameLengths = menu.stream() 
 .map(Dish::getName) 
 .map(String::length) 
 .collect(toList());

6.流的扁平化

对于一张单词表，如何返回一张列表，列出里面各不相同的字符呢？例如，给定单词列表 ["Hello","World"]，你想要返回列表 ["H","e","l", "o","W","r","d"] 。你可能会认为这很容易，你可以把每个单词映射成一张字符表，然后调用distinct 来过滤

重复的字符。第一个版本可能是这样的：

words.stream()
.map(word -> word.split(""))
.distinct()
.collect(toList());

这个方法的问题在于，传递给map方法的Lambda为每个单词返回了一个String[]（String 列表）。因此，map返回的流实际上是Stream<String[]>类型的。你真正想要的是用 Stream<String>来表示一个字符流。如图

List<String> uniqueCharacters = 
 words.stream() 
 .map(w -> w.split("")) 
 .flatMap(Arrays::stream) 
 .distinct() 
 .collect(Collectors.toList());

使用 flatMap 方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所有使用map(Arrays::stream) 时生成的单个流都被合并起来，即扁平化为一个流。图 5-6 说明了使用flatMap 方法的效果。你可以像下面这样使用flatMap来解决这个问题：

一言以蔽之， flatmap 方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流。

例子：

参考文章：

https://blog.csdn.net/lu930124/article/details/77595585

KirioYoLo

关注

1
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
java8 新特性快速入门

目录一、Stream流简易操作demo1、分组2、List转Map3、过滤Filter4、求和5、查找流中最大最小值6、去重二、Stream流进阶操作1、筛选满足某些条件的前N条数据2、用谓词筛选3、跳过元素4、流的扁平化利用java8新特性，可以用简洁高效的代码来实现一些数据处理。一、Stream流简易操作demo定义1个Apple对...
复制链接

扫一扫