一、概述

1、基础数据类型

对象

class Strudent{
    String n;
    int m;
    String x;
    //set\get\构造省略
}

集合

List<Strudent> list = new ArrayList<Strudent>();
list.add(new Strudent("b", 1, "女"));
list.add(new Strudent("a", 2, "男"));
list.add(new Strudent("d", 2, "女"));
list.add(new Strudent("c", 2, "男"));

数组

String[] array = {"b","a","d","c","c"}; 
Integer[] items = {1, 2, 3};

二、使用

1、遍历forEach

//数组
Arrays.asList(items).forEach(item->{System.out.print(item+" ");});
//集合
list.forEach(item->{此处根据需要写自己的逻辑代码});
//map
map.forEach( (k,v)->{System.out.println(k+":"+v);} );

2、过滤filter

List<Strudent> newList = list.stream().filter(promate-> promate.getM()==3).collect(Collectors.toList());

3、转换map\mapToInt\mapToDouble\mapToLong等,转为集合或数组

map转换为其他对象集合

List<SecurityConfig> newList = rlist.stream().map(roles -> new SecurityConfig(roles.getRoleName())).collect(Collectors.toList());

mapToInt转换为数组

int[] array = List.stream().mapToInt(Strudent::getM).toArray();
String[] array = List.stream().map(Strudent::getN).toArray(String[]::new);

4、转换collect

Collectors可以直接进行对象转换，根据类型不同，转换赋值方式稍有差异。主要有Collectors.toMap、Collectors.toList、Collectors.toSet等。
如：list转map

//直接转为map，key与value均可自定义设置。
Map<Integer, String> map = list.stream().collect(Collectors.toMap(Strudent::getM,Strudent::getX));

5、拼接join

join拼接为完整字符串

String str= List.stream().mapToInt(Strudent::getM).collect(Collectors.joining(";")

6、去重distinct

与SQL中的distinct方法一样作用
单条件：

list.stream().filter(...).map(...).distinct().collect(Collectors.toList());

多条件： 直接拼接在一起就可以了，返回的是元对象集合

list.stream().collect(
                Collectors.collectingAndThen(
                        Collectors.toCollection(
                                () -> new TreeSet<>(Comparator.comparing(strudent-> strudent.getM() + strudent.getN()))
                        ), ArrayList::new
                )
        );

7、统计count、sum、average、min、max

统计count返回的是long结果，不是int，需要注意。

long weekCount = list.stream().filter(archi->"推送".equals(archi.getImports())).filter(archi->DataUtil.isThisWeek(archi.getCreateDate())).count();

list.stream().mapToDouble(User::getHeight).sum()//和
list.stream().mapToDouble(User::getHeight).max()//最大
list.stream().mapToDouble(User::getHeight).min()//最小
list.stream().mapToDouble(User::getHeight).average()//平均值

8、排序sort

List对象集合自定义排序，列出了以前的用法以及新用法。

Java8之前，使用匿名内部类的基本排序：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student user1, Student user2) {
        return user1.getX().compareTo(user2.getX());
    }
});

Java8采用lamda：

//法一：根据匿名内部类修改
Collections.sort(list,(Student user1, Student user2) ->user1.getX().compareTo(user2.getX()));
//单条件
Collections.sort(list,Comparator.comparing(Student :: getM));
list.sort(Comparator.comparing(Student::getM));
//单条件降序
list.sort(Comparator.comparing(Student::getM).reversed());
//多条件，nullsLast避免空值 naturalOrder按自然顺序比较可比较对象，返回序列化对象
list.sort(Comparator.comparing(Strudent::getM, Comparator.nullsLast(Comparator.naturalOrder())).thenComparing(Strudent::setX));
//自定义多条件
list.sort((user1,user2)->{
    if (user1.getX().equals(user2.getX())) {
        return user1.getM() - user2.getM();
    } else {
         return user1.getX().compareTo(user2.getX());
    }
});

List<Map<String, Object>>带有map集合特殊一点，通过“-”控制正序倒叙

List<Map<String, Object>> listMap = reList.stream().sorted((i, j) -> -(Convert.toInt(j.get("status"), 0) - Convert.toInt(i.get("status"), 0))).collect(Collectors.toList());

Integer[] archiIds = list.stream().filter(predicate->predicate.getCategoryId() == 1).mapToInt(ArchiParam :: getArchiId).boxed().toArray(Integer[]::new);
                List<ArchiJournal> journals = journalService.getArchiExcels(archiIds);
                List<ExcelJournal> excelJournals = journals.stream()
                        .map(mapper->{
                            ExcelJournal excelJournal = new ExcelJournal(mapper.getId(), mapper.getAchId(), mapper.getDataType(), mapper.getTitle(), mapper.getSource(), DateUtil.format(mapper.getPubTime(), "yyyy-MM-dd"), mapper.getAuthor(), mapper.getKeyword(), mapper.getInclude(), mapper.getSummary(), mapper.getDomain(), mapper.getStatus(), mapper.getYear(), mapper.getRoll(), mapper.getPeriod(), String.valueOf(mapper.getPageCount()), mapper.getPage(), mapper.getFundingLabel(), mapper.getDoi(), mapper.getOrgan(), mapper.getSrcDatabase(), mapper.getLink(), mapper.getDbProvider(), mapper.getLa(), mapper.getIsbn(), mapper.getCn(), null, null, mapper.getAuthor(), DateUtil.format(mapper.getCreateTime(), "yyyy-MM-dd"));
                            excelJournal.setFirstAuthers(mapper.getAuthorInfos().stream().filter(Author->Author.getIsFirst()).map(Author->new String(Author.getAuthorName())).collect(Collectors.joining(";")));
                            excelJournal.setContactAuthers(mapper.getAuthorInfos().stream().filter(Author->Author.getIsContact()).map(Author->new String(Author.getAuthorName())).collect(Collectors.joining(";")));
                            return excelJournal;
                        }).collect(Collectors.toList());

倒叙直接.reversed()

list.stream().sorted().reversed();

依旧还有很多场景的使用方法，类似于整形大小（字符串长度）排序

List<Integer> list = Arrays.asList(11,22,1,333,65, 2, 3, 4, 5, 6, 7);
// 现在可以直接使用List.sort()方法，结合Lambda表达式实现对list元素排序
list.sort((i1, i2) -> i1 - i2);
// 还可以进一步简化成如下进行排序
list.sort(Comparator.comparingInt(Integer::intValue));

9、分组groupingBy

只是一个例子，将时间按月份把数据分组并统计。也可以按照某一个对象的字段分组为不同的集合，不直接统计。DateUtil使用的是hutool工具jar包。

//分组后直接统计
Map<Object, Long> catyMap = list.stream()
    .collect(Collectors.groupingBy(archi -> DateUtil.format(archi.getCreateDate(),"yyyy-MM"), Collectors.counting()));
//只进行分组
Map<String, List<Student>> catyMap = list.stream()
    .collect(Collectors.groupingBy(Student :: getX));

10、校验Optional

optional.isPresent()校验是否有值

Optional<ArchiPerson> optional = archiPer.stream().filter(predicate->predicate.getUserName().equals(author.getActiveUser())).findFirst();
if (optional.isPresent()) {System.out.println("isPresent有符合条件的值返回true，否则为false。");}

optional.get()用于获取第一个符合条件的值

ArchiPerson a = optional.get();

11、包含anyMatch，allMatch，noneMatch

anyMatch表示，判断的条件里，任意一个元素成功，返回true
allMatch表示，判断条件里的元素，所有的都是，返回true
noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

//有就是true，不管几个
boolean re = List.stream().anyMatch(strudent-> (strudent.getM() == 1))
//有且全部都是，才为true
boolean re = List.stream().allMatch(strudent-> (strudent.getM() == 1))
//全部都不是，才为true
boolean re = List.stream().noneMatch(strudent-> (strudent.getM() == 1))

12、分页-跳过skip、截取断流limit

对于lamda中的skip，我多用于分页、截取部分数量等情况，当然还要配合limit、sorted等，视情况而定。limit断流，使其元素不能超过给定数量，就是每页条数。

        List<Integer> list = Arrays.asList(11,22,1,333,65, 2, 3, 4, 5, 6, 7);

        //1、当前页
        int pageNum = 4;
        //2、每页条数
        int pageSize = 5;
        //3、总条数
        int totalNum = list.size();
        //4、总页数
        int totalPage = totalNum % pageSize == 0 ? totalNum / pageSize : totalNum / pageSize + 1;
        
        //当前页不能大于总页数的判断，超出为最大页值
        if(pageNum>totalPage) pageNum = totalPage;
        //5、当前页起始位置
        int pageIndex = pageNum <= 1 ? 0 : (pageNum - 1) * pageSize;
        
        List<Integer> collect = list.stream().skip(pageIndex).limit(pageSize).collect(Collectors.toList());
 
        System.out.println(collect);

若是只截取集合中的前N条数据，直接使用limit即可

list.stream().limit(10).collect(Collectors.toList());

13、批量替换replaceAll

可以根据需要调整需要的返回内容

List<String> list = Arrays.asList("1","12","2","45", "67", "56", "91");
list.replaceAll(str -> str.contains("1") ? "0" : str);

三、总结

1、可以整合使用，.stream()转流之后可以接多个filter再接map转换等。
2、collect（）使用方法较多，可以转为字符串、集合、数组都没问题，看需要。

待处理问题

1、两个list进行遍历，类似冒泡那种，只不过排序换成拼接的实现。目前没有找到合适的方法，仅仅是利用forEach精简了代码而已。应该是我研究不到位，有想法的可以告诉我一声啊

List<String> list1 = Arrays.asList("调","试");
List<String> list2 = Arrays.asList("遍","历");

List<String> list3 = new ArrayList<>();
//Java7及以下
for(String str1 : list1){
    for(String str2 : list2){
        list3.add(str1+str2);
    }
}
//Java8
list1.forEach(str1 -> list2.forEach(str2 -> list3.add(str1+str2)));