首页 > > 程序设计 > Java技术 >

Java8 Stream —— 更丝滑的集合操作方式

2019-12-13 06:37:27来源：博客园阅读 ()

Java8 Stream —— 更丝滑的集合操作方式

一.概念

Stream是一种可供流式操作的数据视图有些类似数据库中视图的概念它不改变源数据集合如果对其进行改变的操作它会返回一个新的数据集合。

总的来讲它有三大特性：在之后我们会对照着详细说明

1、stream不存储数据

2、stream不改变源数据

3、stream的延迟执行特性

二.优点

1、代码简洁，函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

2、多核友好，Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下parallel()方法。

三.Stream API常用方法

Stream操作分类
中间操作(Intermediate operations)	无状态(Stateless)	unordered() filter() map() mapToInt() mapToLong() mapToDouble() flatMap() flatMapToInt() flatMapToLong() flatMapToDouble() peek()
中间操作(Intermediate operations)	有状态(Stateful)	distinct() sorted() sorted() limit() skip()
结束操作(Terminal operations)	非短路操作	forEach() forEachOrdered() toArray() reduce() collect() max() min() count()
结束操作(Terminal operations)	短路操作(short-circuiting)	anyMatch() allMatch() noneMatch() findFirst() findAny()

Stream上的所有操作分为两类：中间操作和结束操作，中间操作只是一种标记，只有结束操作才会触发实际计算。

中间操作又可以分为无状态的和有状态的：

无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果；

结束操作又可以分为短路操作和非短路操作

短路操作是指不用处理全部元素就可以返回结果，比如找到第一个满足条件的元素。之所以要进行如此精细的划分，是因为底层对每一种情况的处理方式不同。

常用中间件

filter：过滤流，过滤流中的元素，返回一个符合条件的Stream

map：转换流，将一种类型的流转换为另外一种流。（mapToInt、mapToLong、mapToDouble 返回int、long、double基本类型对应的Stream）

flatMap：简单的说，就是一个或多个流合并成一个新流。（flatMapToInt、flatMapToLong、flatMapToDouble 返回对应的IntStream、LongStream、DoubleStream流。）

distinct：返回去重的Stream。

sorted：返回一个排序的Stream。

peek：主要用来查看流中元素的数据状态。

limit：返回前n个元素数据组成的Stream。属于短路操作

skip：返回第n个元素后面数据组成的Stream。

结束操作

forEach: 循环操作Stream中数据。

toArray: 返回流中元素对应的数组对象。

reduce: 聚合操作，用来做统计。

collect: 聚合操作，封装目标数据。

min、max、count: 聚合操作，最小值，最大值，总数量。

anyMatch: 短路操作，有一个符合条件返回true。

allMatch: 所有数据都符合条件返回true。

noneMatch: 所有数据都不符合条件返回true。

findFirst: 短路操作，获取第一个元素。

findAny: 短路操作，获取任一元素。

forEachOrdered: 暗元素顺序执行循环操作。

四.常用场景和方法举例

1.迭代

forEach()方法：void forEach(Consumer< ? super T> action);

peek()方法：Stream peek(Consumer< ? super T> action);

List<String> list=...
// 传统for循环
for (String s : list) {
    System.out.println(s);
}

// 使用forEach（结束操作）
list.stream().forEach(x -> {
    System.out.println(x);
});

// 使用peek（中间操作）
list.stream().peek(x -> {
    System.out.println(x);
}).collect(Collectors.toList());

2.转换

map()方法：Stream map(Function< ? super T, ? extends R> mapper);

public class Person {
    private Integer  id;
    private String name;
    private String sex;
    private Integer age;
    //提供get，set，和满参构造函数
}

public class TestMap {
　　public static void main(String[] args) {
　　　　List<Person> persionList = new ArrayList<Person>();
　　　　persionList.add(new Person(1,"张三","男",38));
　　　　persionList.add(new Person(2,"小小","女",2));
　　　　persionList.add(new Person(3,"李四","男",65));
　　　　persionList.add(new Person(4,"王五","女",20));
　　　　persionList.add(new Person(5,"赵六","男",38));
　　　　persionList.add(new Person(6,"大大","男",65));

　　　　//1、只取出该集合中所有姓名组成一个新集合
　　　　List<String> nameList=persionList.stream().map(Person::getName).collect(Collectors.toList());
　　　　System.out.println(nameList.toString());

　　　　//2、只取出该集合中所有id组成一个新集合
　　　　List<Integer> idList=persionList.stream().mapToInt(Person::getId).boxed().collect(Collectors.toList());
　　　　System.out.println(idList.toString());

　　　　//3、list转map，key值为id，value为Person对象
　　　　Map<Integer, Person> personmap = persionList.stream().collect(Collectors.toMap(Person::getId, person -> person));
　　　　System.out.println(personmap.toString());

　　　　//4、list转map，key值为id，value为name
　　　　Map<Integer, String> namemap = persionList.stream().collect(Collectors.toMap(Person::getId, Person::getName));
　　　　System.out.println(namemap.toString());

　　　　//5、进行map集合存放，key为age值 value为Person对象 它会把相同age的对象放到一个集合中
　　　　Map<Integer, List<Person>> ageMap = persionList.stream().collect(Collectors.groupingBy(Person::getAge));
　　　　System.out.println(ageMap.toString());

　　　　//6、获取最小年龄
　　　　Integer ageMin = persionList.stream().mapToInt(Person::getAge).min().getAsInt();
　　　　System.out.println("最小年龄为: "+ageMin);

　　　　//7、获取最大年龄
　　　　Integer ageMax = persionList.stream().mapToInt(Person::getAge).max().getAsInt();
　　　　System.out.println("最大年龄为: "+ageMax);

　　　　//8、集合年龄属性求和
　　　　Integer ageAmount = persionList.stream().mapToInt(Person::getAge).sum();
　　　　System.out.println("年龄总和为: "+ageAmount);
　　}
}

3.过滤

filter()方法：Stream filter(Predicate< ? super T> predicate);

public class TestFilter {
　　public static void main(String[] args) {
　　　　List<Person> persionList = new ArrayList<Person>();
　　　　persionList.add(new Person(1, "张三", "男", 8));
　　　　persionList.add(new Person(2, "小小", "女", 2));
　　　　persionList.add(new Person(3, "李四", "男", 25));
　　　　persionList.add(new Person(4, "王五", "女", 8));
　　　　persionList.add(new Person(5, "赵六", "女", 25));
　　　　persionList.add(new Person(6, "大大", "男", 65));

　　　　//1、查找年龄大于20岁的人数
　　　　long  age=persionList.stream().filter(p->p.getAge()>20).count();
　　　　System.out.println(age);

　　　　//2、查找年龄大于20岁，性别为男的人数
　　　　List<Person>  ageList=persionList.stream().filter(p->p.getAge()>20).filter(p->"男".equals(p.getSex())).collect(Collectors.toList());
　　　　System.out.println(ageList.size());
　　}
}

4.排序

sorted() 排序方法：

public class test {
    public static void main(String[] args) {
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map1 = new HashMap<>();
        map1.put("id", "1");
        map1.put("name", "我是一");
        list.add(map1);
        Map<String, String> map3 = new HashMap<>();
        map3.put("id", "3");
        map3.put("name", "我是三");
        list.add(map3);
        Map<String, String> map2 = new HashMap<>();
        map2.put("id", "2");
        map2.put("name", "我是二");
        list.add(map2);
        System.out.println(list);

        // 使用sorted
        list = list.stream().sorted(Comparator.comparingInt(x -> Integer.parseInt(x.get("id")))).collect(Collectors.toList());
        System.out.println(list);
        
        // 其他方式
        Collections.sort(list, (a, b) -> (a.get("id")).compareTo(b.get("id")));
        System.out.println(list);
        
    }
}