Java8 使用list. stream().filter()过滤List对象（查找符合条件的对象集合），list.stream()根据某个属性排序，List进行分页处理，自定义分页工具类

简介：

本文主要说明在Java8及以上版本中，使用stream().filter()来过滤一个List对象，查找符合条件的对象集合。
List对象类（OnlineRegister）

测试数据：

使用filter()过滤List

此处是要通过一个id值获取符合这个id值的集合数据，此处的id值还不明确，所以测试的时候是写死的。然后再根据这个id值筛选出来的集合对象进行下一步筛选过滤，通过传入的参数进行筛选匹配符合的集合对象。

//1. 筛选当前子系统的数据 todo 带获取systemId
        Integer systemId = 1;
        if(systemId != null){
            onlineRegisters = onlineRegisters.stream().filter(info -> null != info.getSystemId() && info.getSystemId().equals(systemId)).collect(Collectors.toList());
        }
        //2. 根据条件筛选
        if(!StringUtils.isEmpty(listVoterVO.getName())){
            //根据用户筛选
            onlineRegisters = onlineRegisters.stream().filter(info -> !StringUtils.isEmpty(info.getUserName()) && info.getUserName().contains(listVoterVO.getName())).collect(Collectors.toList());
        }
        if(!StringUtils.isEmpty(listVoterVO.getHouseholdRegistration())){
            //根据户籍地区县筛选
            onlineRegisters = onlineRegisters.stream().filter(info -> !StringUtils.isEmpty(info.getHouseholdRegistration()) && info.getHouseholdRegistration().contains(listVoterVO.getHouseholdRegistration())).collect(Collectors.toList());
        }
        if(!StringUtils.isEmpty(listVoterVO.getCandidateType())){
            //根据参选地类型筛选
            onlineRegisters = onlineRegisters.stream().filter(info -> !StringUtils.isEmpty(info.getCandidateType()) && info.getCandidateType().equals(listVoterVO.getCandidateType())).collect(Collectors.toList());
        }

综上所用的方法都是使用的stream().filter()，之间再进行判断获取自己想要的数据，最终方法如下：

根据某个属性添加条件过滤数据，

 list = list.stream().filter(u -> !u.getType().equals("访客")).collect(Collectors.toList());

判断一组对象里面有没有属性值是某个值

 boolean add = list.stream().anyMatch(m -> "王五".equals(m.getName()));

取出一组对象的某个属性组成一个新集合

List<String> names=list.stream().map(PersonData::getName).collect(Collectors.toList());

list集合使用stream()进行排序

• 返回 对象集合以类属性一升序排序

list.stream().sorted(Comparator.comparing(类::属性一));

• 返回 对象集合以类属性一降序排序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed());//先以属性一升序,结果进行属性一降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()));//以属性一降序

• 返回 对象集合以类属性一升序 属性二升序

list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二));

• 返回 对象集合以类属性一降序 属性二升序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二));//先以属性一升序,升序结果进行属性一降序,再进行属性二升序

list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二));//先以属性一降序,再进行属性二升序

• 返回 对象集合以类属性一降序 属性二降序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,升序结果进行属性一降序,再进行属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一,Comparator.reverseOrder()).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一降序,再进行属性二降序

• 返回 对象集合以类属性一升序 属性二降序 注意两种写法

list.stream().sorted(Comparator.comparing(类::属性一).reversed().thenComparing(类::属性二).reversed());//先以属性一升序,升序结果进行属性一降序,再进行属性二升序,结果进行属性一降序属性二降序
 
list.stream().sorted(Comparator.comparing(类::属性一).thenComparing(类::属性二,Comparator.reverseOrder()));//先以属性一升序,再进行属性二降序

小编在这里使用了上面第二种的第二个方法进行以时间倒叙排列，这里的属性就是你想排序的字段。

onlineRegisters.stream().sorted(Comparator.comparing(OnlineRegister::getCreateTime, Comparator.reverseOrder())).collect(Collectors.toList());

自定义分页工具类

自定义工具栏：

 /**
         * 自定义List分页工具
         * @author hanwl
         */
        public class PageUtil {

            /**
             * 开始分页
             * @param list
             * @param pageNum 页码
             * @param pageSize 每页多少条数据
             * @return
             */
            public static List startPage(List list, Integer pageNum,
                    Integer pageSize) {
                if (list == null) {
                    return null;
                }
                if (list.size() == 0) {
                    return null;
                }
    
                Integer count = list.size(); // 记录总数
                Integer pageCount = 0; // 页数
                if (count % pageSize == 0) {
                    pageCount = count / pageSize;
                } else {
                    pageCount = count / pageSize + 1;
                }
    
                int fromIndex = 0; // 开始索引
                int toIndex = 0; // 结束索引
    
                if (pageNum != pageCount) {
                    fromIndex = (pageNum - 1) * pageSize;
                    toIndex = fromIndex + pageSize;
                } else {
                    fromIndex = (pageNum - 1) * pageSize;
                    toIndex = count;
                }
    
                List pageList = list.subList(fromIndex, toIndex);
    
                return pageList;
            }
        }

第二种：

import cn.gov.ny.voters.bean.vo.PageVO;

import java.util.List;


public class PageUtils {

    public static PageVO getPageContentByList(List list, int pageNo, int pageSize) {

        PageVO pageVO  = new PageVO();

        //总记录数
        int total = list.size();
        int totalPages = total / pageSize;
        if (total % pageSize != 0){
            totalPages ++;
        }
        // 开始索引
        int fromIndex = (pageNo -1) * pageSize;
        // 结束索引
        int toIndex = fromIndex + pageSize;
        // 如果结束索引大于集合的最大索引，那么规定结束索引=集合大小
        if(toIndex > total){
            toIndex = total;
        }
        if(fromIndex <= total){
            list = list.subList(fromIndex, toIndex);
        }

        pageVO.setPageSize(pageSize);
        pageVO.setPageNum(pageNo);
        pageVO.setStartRow(fromIndex);
        pageVO.setEndRow(toIndex);
        pageVO.setTotal(total);
        pageVO.setPages(totalPages);
        pageVO.setData(list);

        return pageVO;

    }
}

import com.github.pagehelper.Page;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.List;

@Data
public class PageVO<T> {

    /**
     * 页码，从1开始
     */
    private int pageNum;
    /**
     * 页面大小
     */
    private int pageSize;
    /**
     * 起始行
     */
    private int startRow;
    /**
     * 末行
     */
    private int endRow;
    /**
     * 总条数
     */
    @ApiModelProperty("总条数")
    private int total;
    /**
     * 总页数
     */
    private int pages;
    /**
     * 数据List
     */
    @ApiModelProperty("分页数据")
    private List<T> data;

    public PageVO() {
    }

    public PageVO(Page<T> page, List<T> data) {
        this.pageNum = page.getPageNum();
        this.pageSize = page.getPageSize();
        this.startRow = page.getStartRow();
        this.endRow = page.getEndRow();
        this.total = (int) page.getTotal();
        this.pages = page.getPages();

        this.data = data;
    }

    public PageVO(PageVO page, List<T> data) {
        this.pageNum = page.getPageNum();
        this.pageSize = page.getPageSize();
        this.startRow = page.getStartRow();
        this.endRow = page.getEndRow();
        this.total = (int) page.getTotal();
        this.pages = page.getPages();

        this.data = data;
    }

    // 重新计算页数
    public void reCalc(int total) {
        this.total = total;
        pages = total / pageSize;
        if (total % pageSize != 0) {
            pages++;
        }
    }

}