java8-stream用法

一、概述
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

特点：

        1 . 不是数据结构，不会保存数据。

        2. 不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）

        3. 惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。

二、我们用代码进行测试

1.所需的实体类

public class car {
    private  String id;
    private  String name;
    private  String displacement;
    private double price;

    @Override
    public String toString() {
        return "car{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", displacement='" + displacement + '\'' +
                ", price=" + price +
                '}';
    }

    public car(String id, String name, String displacement, double price) {
        this.id = id;
        this.name = name;
        this.displacement = displacement;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDisplacement() {
        return displacement;
    }

    public void setDisplacement(String displacement) {
        this.displacement = displacement;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

2.再写一个测试类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class test {
    public  static List<String> getStringList(){
        List<String> list =  Arrays.asList("333","111","222","444","222");
        return list;
    }
    public static ArrayList<car> getList(){
        car c1 = new car("0001","大众","2.0T",21.9);
        car c2 = new car("0002","宝马","3.0T",31.9);
        car c3 = new car("0003","奔驰","4.0T",41.9);
        car c4 = new car("0004","保时捷","5.0T",51.9);
        car c5 = new car("0004","保时捷","5.0T",51.9);
        ArrayList list = new ArrayList<car>();
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
        list.add(c5);
        return list;
    }
}

3.常见用法

public static void main(String[] args) {
        //1.遍历流
        getList().stream().forEach(t -> System.out.println(t.getName()));  
    }

 结果：大众 宝马 奔驰 保时捷 保时捷

public static void main(String[] args) {
     
        //2.filter过滤
        getList().stream().filter(t ->t.getName().equals("宝马")).collect(Collectors.toList()).stream().forEach(t -> System.out.println("过滤名字为宝马的--"+ t.getName()));
        getList().stream().filter(t ->t.getPrice()>32).collect(Collectors.toList()).stream().forEach(t -> System.out.println("过滤价格大于32--"+ t.getName()));

    }

 结果： 

过滤名字为宝马的--宝马
过滤价格大于32--奔驰
过滤价格大于32--保时捷
过滤价格大于32--保时捷

public static void main(String[] args) {
        //3.map转换 就是将对应的元素按照给定的方法进行转换。
        getList().stream().map(t ->"价格"+t.getPrice()).collect(Collectors.toList()).stream().forEach(t -> System.out.println(t));
      
    }

  结果：

价格21.9
价格31.9
价格41.9
价格51.9
价格51.9

public static void main(String[] args) {

        //4.distinct（去重）
        // JDK8中有双冒号的用法，就是把方法当做参数传到stream内部，使stream的每个元素都传入到该方法里面执行一下。
        getStringList().stream().distinct().forEach(System.out::println);       

    }

  结果：

333
111
222
444

public static void main(String[] args) {
        //5.sorted 排序
        getStringList().stream().sorted().forEach(System.out::println);

    }

  结果：

111
222
222
333
444

 public static void main(String[] args) {
        //6.限制返回次数
        getStringList().stream().limit(2).forEach(System.out::println);
    }

结果：

333
111

 public static void main(String[] args) {
        //7.skip删除元素
        getStringList().stream().skip(2).forEach(System.out::println);
    }

结果：

222
444
222

 public static void main(String[] args) {

        //8.reduce聚合
        String s = getStringList().stream().reduce("合并",(x ,y)->x + y);
        System.out.println(s);
       
    }

结果：合并333111222444222

 public static void main(String[] args) {
        //9.求最小值min
        Optional<car> rmin = getList().stream().min((s1, s2)->Double.compare(s1.getPrice(),s2.getPrice()));
        System.out.println("最小值："+rmin.toString());
        //10.求最大值max
        Optional<car> rmax = getList().stream().max((s1, s2)->Double.compare(s1.getPrice(),s2.getPrice()));
        System.out.println("最大值："+rmax.toString());
       
    }

结果：

最小值：Optional[car{id='0001', name='大众', displacement='2.0T', price=21.9}]
最大值：Optional[car{id='0004', name='保时捷', displacement='5.0T', price=51.9}]

public static void main(String[] args) {

        //11.anyMatch/allMatch/noneMatch（匹配）
        boolean allMatch= getList().stream().allMatch(t->t.getPrice()>15);
        if(allMatch){ System.out.println("所有的车价格都大于15万"); }
        boolean anyMatch= getList().stream().anyMatch(t->t.getName().equals("奔驰"));
        if(anyMatch){ System.out.println("这里面有奔驰车"); }
        boolean noneMatch = getList().stream().noneMatch(t->t.getDisplacement().equals("8.0T"));
        if(noneMatch){ System.out.println("这里面没有8.0T的车"); }
    }
 

结果：

所有的车价格都大于15万
这里面有奔驰车
这里面没有8.0T的车