94 java8新特性_5 _Stream API

94 java8新特性_5 _Stream API

什么是Stream

• 之前学的IO流是对硬盘或网络数据的读写操作
• 流（Stream）中保存对集合或数组数据的操作，和集合类似，但集合中保存的是数据，流中保存的是操作
• 类似流水线：

Stream特点

• Stream 自己不会存储元素。
• Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
• Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream使用步骤

• 创建

  • 新建一个流

• 中间操作

  • 在一个或多个步骤中，将初始Stream转化到另一个Stream的中间操作

• 终止操作

  • 使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。在这之后，该Stream就 不能使用了。

创建Stream

• 通过Clollection对象的stream() 或 parallelStream()方法 <方法里使用了多线程>
• 通过Arrays类的stream()方法
• 通过Stream接口中的of()、iterate()、generate()方法
• 通过IntStream、 LongStream、 DoubleStream 接口中的of、range、rangeClosed方法

代码:

package com.wlw.chapter13_java8.demo02_stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

// 创建流（Stream）
public class Demo01 {
    public static void main(String[] args) {
        //1.通过Clollection对象的stream()或parallelStream()方法
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("xiaoming");
        arrayList.add("xiaoli");
        arrayList.add("xiaohong");
        Stream<String> stream1 = arrayList.stream();
        //遍历
        //stream1.forEach(s -> System.out.println(s));
        stream1.forEach(System.out::println);

        System.out.println("------------------------------------------------");
        //2.通过Arrays类的stream()方法
        String[] array = {"aaa","bbb","ccc"};
        Stream<String> stream2 = Arrays.stream(array);
        stream2.forEach(System.out::println);//遍历

        System.out.println("------------------------------------------------");
        //3.通过Stream接口中的of()、iterate()、generate()方法
        Stream<Integer> stream3 = Stream.of(10, 20, 30, 40);
        stream3.forEach(System.out::println);
        //迭代流
        System.out.println("------迭代流-----");
        Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
        iterate.limit(5).forEach(System.out::println);

        System.out.println("------生成流-----");
        Stream<Integer> generate = Stream.generate(() -> new Random().nextInt(100));
        generate.limit(5).forEach(System.out::println);
        System.out.println("------------------------------------------------");
        //4.通过IntStream、 LongStream、 DoubleStream 接口中的of、range、rangeClosed方法
        IntStream intStream = IntStream.of(11, 21, 31, 41);
        intStream.forEach(System.out::println);

        IntStream range = IntStream.range(0,5);//开合 不含尾
        range.forEach(System.out::println);

        IntStream intStream1 = IntStream.rangeClosed(1, 5);//闭合 含尾
        intStream1.forEach(System.out::println);
    }
}

中间操作、终止操作

• 中间操作：
  • filter（过滤） limit（限制） skip（跳过） distinct（去重） sorted（排序）
  • map（把数据映射成另外一组数据） parallel（并行流）

代码1:

package com.wlw.chapter13_java8.demo02_stream;

import com.wlw.chapter13_java8.demo01_lambda.Employee;
import java.util.ArrayList;

//中间操作
public class Demo02 {
    public static void main(String[] args) {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("小明",12));
        list.add(new Employee("小刘",19));
        list.add(new Employee("小红",18));
        list.add(new Employee("小李",20));
        list.add(new Employee("小李",20));
        //filter（过滤）  limit（限制） skip（跳过） distinct（去重）  sorted（排序）
        //filter（过滤）
        System.out.println("---------filter（过滤）-----------");
        list.stream()
                .filter(employee -> employee.getAge()>15).forEach(System.out::println);

        //limit（限制）
        System.out.println("---------limit（限制）-----------");
        list.stream()
                .limit(2).forEach(System.out::println);

        //skip（跳过）
        System.out.println("---------skip（跳过）-----------");
        list.stream()
                .skip(2).forEach(s->System.out.println(s));

        //distinct（去重） 需要重写hashCoed() 、equals()方法
        System.out.println("---------distinct（去重）-----------");
        list.stream()
                .distinct().forEach(System.out::println);

        //sorted（排序）
        System.out.println("---------sorted（排序）-----------");
        list.stream()
                .sorted((e1,e2)->Integer.compare(e1.getAge(),e2.getAge())).forEach(System.out::println);

        //map（把数据映射成另外一组数据）          parallel（并行流）
        //map（把数据映射成另外一组数据）
        System.out.println("---------map-----------");
        list.stream()
                .map(employee -> employee.getName()).forEach(System.out::println);

        // parallel（并行流） 采用多线程 效率高
        System.out.println("--------parallel-----------");
        list.parallelStream().forEach(System.out::println);
    }
}

代码2:

package com.wlw.chapter13_java8.demo02_stream;

import java.util.ArrayList;
import java.util.UUID;

// 并行流（多线程） 串行流（单线程） 的效率对比   parallel
public class Demo03 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 5000000; i++) {
            arrayList.add(UUID.randomUUID().toString());
        }

        long start = System.currentTimeMillis();
       // long count = arrayList.stream().sorted().count();//单线程：4382
        long count = arrayList.parallelStream().sorted().count(); //多线程：2404
        System.out.println(count);
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));
    }
}

• 终止操作：

  • forEach (遍历) min(最小值) max（最大值） count（元素个数）
  • reduce （规约） collect（收集）

代码:

package com.wlw.chapter13_java8.demo02_stream;

import com.wlw.chapter13_java8.demo01_lambda.Employee;

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

// 终止操作
public class Demo04 {
    public static void main(String[] args) {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("小明",12));
        list.add(new Employee("小刘",19));
        list.add(new Employee("小红",18));
        list.add(new Employee("小李",20));
        list.add(new Employee("小王",25));
        //终止操作 forEach (遍历)   min(最小值)   max（最大值）   count（元素个数）
        //forEach (遍历)
        System.out.println("-----------forEach (遍历)------------");
        list.stream().filter(employee ->{
                System.out.println("过滤了..............");  //Stream的特点：延时执行
                return employee.getAge()>15;
            }).forEach(System.out::println);

        //min(最小值)
        System.out.println("-----------min(最小值)------------");
        Optional<Employee> min = list.stream().min((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println(min);

        // max（最大值）
        System.out.println("----------- max（最大值）------------");
        Optional<Employee> max = list.stream().max((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge()));
        System.out.println(max);

        //count（元素个数）
        System.out.println("-----------count（元素个数）------------");
        long count = list.stream().count();
        System.out.println("人数:"+count);

        //终止操作reduce （规约）   collect（收集）
        //reduce （规约）
        //计算所有人的年龄之和
        System.out.println("-----------reduce （规约）------------");
        Optional<Integer> sum = list.stream().map(employee -> employee.getAge())
                .reduce((x, y) -> x + y);
        System.out.println(sum.get());

        //collect（收集）
        //获取所有人的姓名，封装成一个list集合
        System.out.println("-----------collect（收集）------------");
        List<String> names = list.stream().map(employee -> employee.getName())
                .collect(Collectors.toList());
        System.out.println(names);
    }
}