javaFaker与Java8新特性结合，利用stream流和Lambda表达式对List集合数据进行简单操作笔记

一、简介说明

1.只要是开发工作，都免不了制造一部分数据进行测试，很早之前都是自己手写一些不是很正规的数据进行测试，展示效果总是不尽人意。javaFaker可谓是造数据的神奇，里面含有涉及的领域是越来越丰富，简直是造数神器。
2.stream流和Lambda 表达式，都是推动 Java 8 发布的最重要新特性，我个人体会是在处理集合数据中的操作。Lambda 表达式可以使代码变的更加简洁紧凑，stream流可以执行非常复杂的查找、过滤和映射数据等操作集合，涉及到的api可以实现较多的数据操作。

二、使用案例

1.核心依赖pom.xml
pom.xml

<properties>
	<project.builde.sourceEncoding>UTF-8</project.builde.sourceEncoding>
	<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
	<java.version>1.8</java.version>
</properties>

<dependencies>

	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
		<optional>true</optional>
	</dependency>
       
	<!--javafaker-->
	<dependency>
		<groupId>com.github.javafaker</groupId>
		<artifactId>javafaker</artifactId>
		<version>0.14</version>
	</dependency>

</dependencies>

2.新建实体类UsersDTO.java
UsersDTO.java

package com.basic.hellorabbit.dto;

import lombok.Data;

/**
* @Description:    用户传输类
* @Author:         Joe
* @CreateDate:     2020/5/11 14:11
*/
@Data
public class UsersDTO {

    private String name;
    private Integer age;
    private String job;
    private String address;

    public UsersDTO(String name, Integer age, String job, String address) {
        this.name = name;
        this.age = age;
        this.job = job;
        this.address = address;
    }
}

3.新建数据操作类JavaFakerWay.java
JavaFakerWay.java

package com.basic.hellorabbit.util;

import com.basic.hellorabbit.dto.UsersDTO;
import com.github.javafaker.Faker;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.stream.Collectors;
/**
* @Description:    操作方法对比
* @Author:         Joe
* @CreateDate:     2020/5/11 17:11
*/
@Slf4j
public class JavaFakerWay {

    /**
     * 使用java faker 创建原始数据集合
     * @return
     */
    public static List<UsersDTO> getList(){
        log.info("使用java faker：创建原始数据集合");
        //设置语言、地区
        Locale locale = new Locale("zh","CN");
        //创建对象
        Faker faker = new Faker(locale);
        Random random = new Random();
        List<UsersDTO> usersDTOS = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            UsersDTO usersDTO = new UsersDTO(faker.name().name(),random.nextInt(20)+15,faker.address().fullAddress(),faker.job().seniority());
            System.out.println(usersDTO);
            usersDTOS.add(usersDTO);
        }
        return usersDTOS;
    }

    /**
     * 1.将原始数据中年龄大于20岁用户过滤出来
     * @param usersDTOS
     * @return
     */
    public static List<UsersDTO> getFor(List<UsersDTO> usersDTOS){
        log.info("for循环：过滤");
        List<UsersDTO> users =null;
        if (usersDTOS != null && usersDTOS.size()>0){
            for (int i = 0; i < usersDTOS.size(); i++) {
                UsersDTO usersDTO = usersDTOS.get(i);
                if (usersDTO.getAge()>20){
                    users.add(usersDTO);
                }
            }
        }
        return users;
    }

    /**
     * 2.Lambda表达式:forEach()进行遍历集合
     * item：可以是任意值。类似于for循环(1)中的循环值(usersDTO)
     * 参数列表 -> 表达式
     * 参数列表 -> {表达式集合}
     * 需要注意 lambda 表达式隐含了 return 关键字，所以在单个的表达式中，无需显式的写 return 关键字，
     * 但是当表达式是一个语句集合的时候则需要显式添加 return 关键字，并用花括号{ } 将多个表达式包围起来
     */
    public static List<UsersDTO> getForEach(List<UsersDTO> usersDTOS){
        log.info("forEach()：过滤");
        List<UsersDTO> users =new ArrayList<>();
        usersDTOS.forEach(item->{
            if (item.getAge()>20){
                users.add(item);
            }
        });
        return users;

    }

    /**
     * 3.Lambda表达式:将过滤出来数据按年龄排序
     * Comparator[带有比较器参数的Sort方法]
     * 语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符。
     * @param filter
     * @return
     */
    public static List<UsersDTO> getSort(List<UsersDTO> filter){
        log.info("Lambda表达式：按年龄排序");
        if (filter != null && filter.size()>0){
            filter.sort((o1,o2)->{
                return o1.getAge()-o2.getAge();
            });
        }
        return filter;
    }

    /**
     * 4.stream()流操作:将usersDTOS中年龄大于20岁用户过滤出来
     * filter(item->{})   其中item为每一项。 按照自己的需求来筛选filter中的数据
     * @param usersDTOS
     * @return
     */
    public static List<UsersDTO> getfilter(List<UsersDTO> usersDTOS){
        log.info("stream()流：过滤");
        List<UsersDTO> filterList = usersDTOS.stream().filter(item->item.getAge()>20).collect(Collectors.toList());
        return filterList;
    }

    /**
     * 5.stream()流操作:将过滤出来数据按年龄排序
     * sorted((第一个对象，第二个对象)->返回值)  （升降序看是第几个对象与第几个对象比较:前-后 即升序）
     * @param filter
     * @return
     */
    public static List<UsersDTO> getsortedList(List<UsersDTO> filter){
        log.info("stream()流：按年龄排序");
        List<UsersDTO> sortedList = filter.stream().sorted((o1,o2)->o1.getAge()-o2.getAge()).collect(Collectors.toList());
        return sortedList;
    }
}

注意：排序中的o1与o2，o1-o2：升序；o2-o1：降序

3.新建类JavaFakerTest.java在main方法测试
JavaFakerTest.java

package com.basic.hellorabbit.util;

import com.basic.hellorabbit.dto.UsersDTO;
import lombok.extern.slf4j.Slf4j;

import java.util.List;

/**
* @Description:    使用javaFaker创建数据，并使用Java8新特性 利用stream流和Lambda表达式对List集合进行简单处理
* @Author:         Joe
* @CreateDate:     2020/5/11 15:24
*/
@Slf4j
public class JavaFakerTest {
    public static void main(String[] args) {
        //创建数据
        List<UsersDTO> usersDTOS = JavaFakerWay.getList();

        System.out.println("---------------------------------------------------------------------");
        log.info("usersDTOS.size{}:"+usersDTOS.size());
        System.out.println("---------------------------------------------------------------------");
        //1.将原始数据age大于20岁用户放入filter
        //1.1 for循环过滤
        //List<UsersDTO> filter = JavaFakerWay.getFor(usersDTOS);

        //1.2 Lambda表达式：forEach()进行遍历集合过滤
        //List<UsersDTO> filter = JavaFakerWay.getForEach(usersDTOS);

        //1.3
        List<UsersDTO> filter = JavaFakerWay.getfilter(usersDTOS);

        log.info("filter.size{}:"+filter.size());

        //2.将过滤出来数据按年龄排序
        //2.1 Lambda表达式排序
        //List<UsersDTO> filterSort = JavaFakerWay.getSort(filter);

        //2.2 stream()流排序
        List<UsersDTO> filterSort = JavaFakerWay.getsortedList(filter);
        System.out.println(filterSort);

    }

}

4.控制台结果

以上是个人使用的部分总结，请多多指点