94 java8新特性_5 _Stream API

94 java8新特性_5 _Stream API

文章目录

• ​​94 java8新特性_5 _Stream API​​

• ​​什么是Stream​​
• ​​Stream特点​​
• ​​Stream使用步骤​​

• ​​创建Stream​​
• ​​中间操作、终止操作​​

什么是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);
}
}

【文章由韩国大带宽服务器 http://www.558idc.com/lg.html处的文章,转载请说明出处】