博客

多个流的中间操作可连成一个流水线,除非流水线上触发终端操作,否则中间操作不会执行任何的处理!而在终止操作执行时一次性全部处理.将这种处理方式称为”惰性求值”

下面我们分三个部分来介绍流的中间操作

1.筛片与切片

筛选与切片中共涉及一下几个方法

• filter() //过渡,从流中排除某些元素

• limit() //截断流,使之不超过指定数量

• distinct() //筛选,通过流所生成元素的hashCode()和equals()方法去除重复元素

• skip() //跳过指定数量的元素

下面我们进行代码示例:

package stream流;
​
import java.util.ArrayList;
​
public class StreamDemo3 {
​
    public static void main(String[] args) {
​
        ArrayList<Integer> list = new ArrayList();
              list.add(1);
              list.add(5);
              list.add(4);
              list.add(9);
              list.add(5);
              list.add(3);
              list.add(2);
        list.stream()
             .filter((e)->{ return e>3;})
             .distinct()
             .limit(3)
             .skip(1)
             .forEach((e)-> System.out.println(e));
​
    }
}

这里我们通过一系列流的中间操作,最终输出的结果为:

4
9

2.映射

• 此处映射就类似于高中函数中所学习的映射,即具有一一对应的关系

此处共涉及到两个方法,下面来逐一说明

①map();

//此方法为接收一个函数作为参数,将元素转换成其他形式或提取信息,该函数会被应用到每个元素上,并将其映射成为一个新的元素

这里我们先自定义一个类

package stream流;
​
class Apple {
​
    private int num;
    private String color;
    private String price;
​
    public Apple(int num, String color, String price) {
        this.num = num;
        this.color = color;
        this.price = price;
    }
​
    public int getNum() {
        return num;
    }
​
    public void setNum(int num) {
        this.num = num;
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
​
    public String getPrice() {
        return price;
    }
​
    public void setPrice(String price) {
        this.price = price;
    }
​
    @Override
    public String toString() {
        return "Apple{" +
                "num=" + num +
                ", color='" + color + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}
​

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
​
public class StreamDemo4 {
​
    public static void main(String[] args) {
​
        Apple apple1 = new Apple(100,"白色","8900");
        Apple apple2 = new Apple(101,"黑色","9900");
        Apple apple3 = new Apple(102,"白色","8500");
        Apple apple4 = new Apple(103,"蓝色","8900");
        Apple apple5 = new Apple(104,"白色","9200");
​
        List<Apple> apples = new ArrayList<>();
              apples.add(apple1);
              apples.add(apple2);
              apples.add(apple3);
              apples.add(apple4);
              apples.add(apple5);
​
        //map();  将其映射为一个新的元素
                apples.stream()
                      .filter(e->{return e.getColor().equals("白色");})
                      .map(Apple::getPrice)
                      .forEach(e-> System.out.println(e));
​
    }
}

这里我们首先使用filter()方法筛选出部分元素,再通过map方法,将其映射为一个新的元素

3.排序

因为排序通常涉及到自然排序与选择排序,因此此处也有两个排序方法

• sorted()

  //自然排序

  package stream流;
  ​
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  ​
  public class SortTest {
  ​
      public static void main(String[] args) {
  ​
          //自然排序
          List<Integer> list = Arrays.asList(21,42,35,2,15,99,85);
          list.stream()
                  .sorted()
                  .forEach(System.out::println);
          
      }
  }
  ​

• sorted() //定制排序

  package stream流;
  ​
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  ​
  public class SortTest {
  ​
      public static void main(String[] args) {
          
          //定制排序
          List<Employee> employees = EmployeeDate.getEmployees();
          employees.stream()
                  .sorted()
                  .forEach(System.out::println);
          
      }
  }
  ​