java 数据源驱动是指什么

转载

killads 2025-01-06 23:50:55

文章标签 java 数据源驱动是指什么 stream User List 操作符 文章分类 Java 后端开发

一、Stream的理解

Stream是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等

在Java8中Stream API作为数据渠道，用于操作数组或者集合等数据源。流本身是不存储数据的，只是移动数据，在移动过程中可能会对数据进行过滤，排序或者其它操作，但是，大多数情况下，流操作本身不会修改数据源，比如，对流排序不会修改数据源的顺序。它只是会创建一个新的流，其中包含排序后的结果

在java中称Stream为流，经常会用流去对集合进行一些流水线的操作。stream就像工厂一样，只需要把集合、命令还有一些参数灌输到流水线中去，就可以加工成得出想要的结果。这样的流水线能大大简洁代码，减少操作

二、Stream的流程

原集合 —> 流  —> 各种操作(过滤、分组、统计) —> 终端操作

Stream流的操作流程一般都是：

将集合转为流
经过各种操作，比如过滤、筛选、分组、计算
终端操作，转化成想要的数据(数据的形式一般是集合，有时也会按照需求输出count计数)

三、Stream的特点

可以“存储”有限个或无限个元素
这里的存储打了引号，是因为元素有可能已经全部存储在内存中，也有可能是根据需要实时计算出来
一个Stream可以轻易地转换为另一个Stream，而不是修改原Stream本身
真正的计算通常发生在最后结果的获取，也就是惰性计算
惰性计算的特点是：一个Stream转换为另一个Stream时，实际上只存储转换规则，并没有任何计算发生

四、Stream的方法

Stream定义的方法如下

java 数据源驱动是指什么_操作符

五、Stream的操作符

Stream的操作符大体上分为两种：中间操作符和终止操作符

5.1 中间操作符

对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符

中间操作符包含8种(排除parallel和sequential，这两个操作并不涉及到对数据流的加工操作)：

map(mapToInt,mapToLong,mapToDouble)
转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符
flatmap(flatmapToInt,flatmapToLong,flatmapToDouble)
拍平操作，比如把 int[]{2,3,4} 拍平变成 2，3，4，也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int、long、double的操作符
limit
限流操作，比如数据流中有10个，只要出前3个就可以使用
distint
去重操作，对重复元素去重，底层使用equals方法
filter
过滤操作，把不想要的数据过滤
peek
挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等
skip
跳过操作，跳过某些元素
sorted(unordered)
排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器

5.2 终止操作符

数据经过中间加工操作，就轮到终止操作符上场
终止操作符用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动，终止操作符只能使用一次

collect
收集操作，将所有数据收集起来，官方的提供的Collectors提供了非常多收集器，Stream的核心在于Collectors
count
统计操作，统计最终的数据个数
findFirst、findAny
查找操作，查找第一个、查找任何一个，返回的类型为Optional
noneMatch、allMatch、anyMatch
匹配操作，数据流中是否存在符合条件的元素返回值为bool值
min、max
最值操作，需要自定义比较器，返回数据流中最大最小的值
reduce
规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce
forEach、forEachOrdered
遍历操作，这里就是对最终的数据进行消费
toArray
数组操作，将数据流的元素转换成数组

六、API功能举例

首先，定义一个用户对象，包含姓名、年龄、性别和籍贯四个成员变量：

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;
}

这里用lombok简化了实体类的代码

然后创建需要的集合数据，也就是源数据：

//1.构建我们的list
List<User> list= Arrays.asList(
        new User("钢铁侠",40,0,"华盛顿"),
        new User("蜘蛛侠",20,0,"华盛顿"),
        new User("赵丽颖",30,1,"湖北武汉市"),
        new User("詹姆斯",35,0,"洛杉矶"),
        new User("李世民",60,0,"山西省太原市"),
        new User("蔡徐坤",20,1,"陕西西安市"),
        new User("葫芦娃的爷爷",70,0,"山西省太原市")
);

6.1 过滤

6.1.1 stream()/parallelStream() 创建流

创建流：

stream() : 串行流
parallelStream（）: 并行流

6.1.2 filter 过滤(T-> boolean)

比如要过滤年龄在40岁以上的用户，可以这样写：

List<User> filterList = list.stream().filter(user -> user.getAge() >= 40)
        .collect(toList());

filter里面，->箭头后面跟着的是一个 boolean值，可以写任何的过滤条件，就相当于sql中where后面的语句，换句话说，能用sql实现的功能这里都可以实现

打印如下：

java 数据源驱动是指什么_stream_02

6.1.3 distinct 去重

和sql中的distinct关键字很相似。为了看到效果此处在原集合中加入一个重复的

List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
);

//distinct 去重
List<User> distinctList = filterList.stream().distinct()
        .collect(toList());

打印结果：

java 数据源驱动是指什么_User_03

6.1.4 sorted排序

如果流中的元素的类实现了Comparable接口，即有自己的排序规则，那么可以直接调用 sorted()方法对元素进行排序，如：

Comparator.comparingInt

反之, 需要调用sorted((T, T) -> int)实现Comparator接口

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) {
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //sorted()
        List<User> sortedList = list.stream().sorted(Comparator.comparingInt(User::getAge))
                .collect(toList());
    }
}

打印结果：

java 数据源驱动是指什么_List_04

结果按照年龄从小到大进行排序

6.1.5 limit返回前n个元素

如果想知道这里面年龄最小的是谁，可作如下操作：

//limit 返回前n个元素
List<User> limitList = sortedList.stream().limit(1)
        .collect(toList());

java 数据源驱动是指什么_java 数据源驱动是指什么_05

6.1.6 skip跳过

与limit恰恰相反，skip的意思是跳过，也就是去除前n个元素

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) {
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //skip 跳过前n个元素
        List<User> skipList = list.stream().skip(2).collect(toList());
    }
}

打印结果：

java 数据源驱动是指什么_stream_06

前两个人都被去除，列表中剩下5个

6.2 映射

6.2.1 map(T->R)

map是将T类型的数据转为R类型的数据，比如想要设置一个新的list，存储用户所有的城市信息

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) {
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        //map(T->R)
        List<String> cityList = list.stream().map(User::getAddress).distinct().collect(toList());
    }
}

打印结果：

java 数据源驱动是指什么_java 数据源驱动是指什么_07

6.2.2 flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流

//flatMap(T -> Stream<R>)
        List<String> flatList = new ArrayList<>();
        flatList.add("唱,跳");
        flatList.add("rape,篮球,music");
        flatList = flatList.stream().map(s -> s.split(",")).flatMap(Arrays::stream).collect(toList());

打印结果：

java 数据源驱动是指什么_操作符_08

这里原集合中的数据由逗号分割，使用split进行拆分后，得到的是Stream，字符串数组组成的流，要使用flatMap

Arrays::stream

将Stream转为Stream,然后把流相连接，组成了完整的唱、跳、rap、篮球和music

6.3 查找

6.3.1allMatch(T->boolean)

检测是否全部满足参数行为，假如这些用户是网吧上网的用户名单，那就需要检查是不是每个人都年满18周岁

boolean isAdult = list.stream().allMatch(user -> user.getAge() >= 18);

打印结果：

true

6.3.2 anyMatch(T->boolean)

检测是否有任意元素满足给定的条件，比如，想知道同学名单里是否有女生

//anyMatch(T -> boolean） 是否有任意一个元素满足给定的条件
boolean isGirl = list.stream().anyMatch(user -> user.getSex() == 1);

打印结果：

true

说明集合中有女生存在

6.3.3 noneMatch(T -> boolean)

流中是否有元素匹配给定的T -> boolean条件

比如检测有没有来自巴黎的用户

boolean isLSJ = list.stream().noneMatch(user -> user.getAddress().contains("巴黎"));

打印结果：

true

打印true说明没有巴黎的用户

6.3.4 findFirst( )找到第一个元素

Optional<User> fristUser  = list.stream().findFirst();

打印结果：

User(name=钢铁侠, age=40, sex=0, address=华盛顿)

6.3.5 findAny()找到任意一个元素

Optional<User> anyUser  = list.stream().findAny();

打印结果：

User(name=钢铁侠, age=40, sex=0, address=华盛顿)

这里发现findAny返回的也总是第一个元素，那么为什么还要进行区分呢？因为在并行流 parallelStream()中找到的确实是任意一个元素

Optional<User> anyParallelUser  = list.parallelStream().findAny();

打印结果 :

Optional[User(name=李世民, age=60, sex=0, address=山西省太原市)]

6.4 归纳计算

6.4.1 求用户的总人数

long count = list.stream().collect(Collectors.counting());

可以简写为：

long count = list.stream().count();

运行结果：

6.4.2 得到某一属性的最大最小值

// 求最大年龄
Optional<User> max = list.stream().collect(Collectors.maxBy(
Comparator.comparing(User::getAge)));
// 求最小年龄
Optional<User> min = list.stream().collect(Collectors.minBy(
Comparator.comparing(User::getAge)));

运行结果：

java 数据源驱动是指什么_java 数据源驱动是指什么_09

java 数据源驱动是指什么_操作符_10

6.4.3 求年龄总和

// 求年龄总和
int totalAge = list.stream().collect(Collectors.summingInt(User::getAge));

运行结果：

经常会用BigDecimal来记录金钱，假设想得到BigDecimal的总和：

// 获得列表对象金额， 使用reduce聚合函数,实现累加器
BigDecimal sum = myList.stream().map(User::getMoney).reduce(BigDecimal.ZERO,BigDecimal::add);

6.4.4 求年龄平均值

//求年龄平均值
double avgAge = list.stream().collect(Collectors.averagingInt(User::getAge));

运行结果

39.0

6.4.5 一次性得到元素的个数、总和、最大值、最小值

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Log4j
@Builder
public class User {
    //姓名
    private String name;
    //年龄
    private Integer age;
    //性别
    private Integer sex;
    //所在省市
    private String address;

    public static void main(String[] args) {
        List<User> list= Arrays.asList(
                new User("钢铁侠",40,0,"华盛顿"),
                new User("蜘蛛侠",20,0,"华盛顿"),
                new User("赵丽颖",30,1,"湖北武汉市"),
                new User("詹姆斯",35,0,"洛杉矶"),
                new User("李世民",60,0,"山西省太原市"),
                new User("蔡徐坤",18,1,"陕西西安市"),
                new User("葫芦娃的爷爷",70,0,"山西省太原市")
        );

        IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(User::getAge));
    }
}

运行结果：

java 数据源驱动是指什么_java 数据源驱动是指什么_11

6.4.6 字符串拼接

要将用户的姓名连成一个字符串并用逗号分割

String names = list.stream().map(User::getName).collect(Collectors.joining(", "));

运行结果：

钢铁侠, 蜘蛛侠, 赵丽颖, 詹姆斯, 李世民, 蔡徐坤, 葫芦娃的爷爷

6.5 分组

在数据库操作中，经常通过GROUP BY关键字对查询到的数据进行分组，java8的流式处理也提供了分组的功能。使用Collectors.groupingBy来进行分组

6.5.1 根据用户所在城市进行分组

Map<String, List<User>> cityMap = list.stream().collect(Collectors.groupingBy(User::getAddress));

运行结果：

java 数据源驱动是指什么_stream_12

结果是一个map，key为不重复的城市名，value为属于该城市的用户列表。已经实现了分组

6.5.2 二级分组

先根据城市分组再根据性别分组

Map<String, Map<Integer, List<User>>> group = list.stream().collect(
                Collectors.groupingBy(User::getAddress, // 一级分组，按所在地区
                        Collectors.groupingBy(User::getSex))); // 二级分组，按性别

运行结果：

java 数据源驱动是指什么_User_13

6.5.3 统计各城市的用户个数

如果仅仅想统计各城市的用户个数是多少，并不需要对应的list

按城市分组并统计人数：

Map<String, Long> cityCountMap = list.stream().collect(Collectors.groupingBy(User::getAddress,Collectors.counting()));

运行结果：

java 数据源驱动是指什么_操作符_14

6.5.4 过滤再分组并统计人数

Map<String,Long> map = list.stream().filter(user -> user.getAge() <= 30).collect(Collectors.groupingBy(User::getAddress,Collectors.counting()));

运行结果：

java 数据源驱动是指什么_操作符_15

6.5.5 partitioningBy分区

分区与分组的区别在于，分区是按照true和false来分的，因此partitioningBy接受的参数的 lambda也是T -> boolean

//根据年龄是否小于等于30来分区
        Map<Boolean, List<User>> part = list.stream().collect(partitioningBy(user -> user.getAge() <= 30));

运行结果：

java 数据源驱动是指什么_List_16

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：mysql表结构设计 ip字段

下一篇：个双宽GPU卡

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯