目录
本文为过时文，更详细的stream请移步：
一、基本概念
.外部迭代、内部迭代、中间操作、终止操作、惰性求值
import java.util.stream.IntStream;
public class StreamDemo1 {
public static void main(String[] args) {
int[] nums = { 1, 2, 3 };
// 外部迭代
int sum = 0;
for (int i : nums) {
sum += i;
}
System.out.println("结果为：" + sum);
// 使用stream的内部迭代
// map就是中间操作（返回stream的操作）
// sum就是终止操作
int sum2 = IntStream.of(nums).map(StreamDemo1::doubleNum).sum();
System.out.println("结果为：" + sum2);
System.out.println("惰性求值就是终止没有调用的情况下，中间操作不会执行");
IntStream.of(nums).map(StreamDemo1::doubleNum);
}
public static int doubleNum(int i) {
System.out.println("执行了乘以2");
return i * 2;
}
}二、stream的创建
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamDemo2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
// 从集合创建
list.stream();
list.parallelStream(); // 并行流
// 从数组创建
Arrays.stream(new int[] { 2, 3, 5 });
// 创建数字流
IntStream.of(1, 2, 3);
IntStream.rangeClosed(1, 10); // 带边界，1-10的流
// 使用random创建一个无限流
new Random().ints().limit(10);
Random random = new Random();
// 自己产生流
Stream.generate(() -> random.nextInt()).limit(20);
}
}三、stream中间操作
jdk8函数接口参考：函数式编程-lambda函数与jdk8自带的函数接口_秃了也弱了。的博客-CSDN博客
基本上，一个参数的是无状态操作，两个参数的是有状态操作
public static void main(String[] args) {
String str = "my name is 007";
// 把每个单词的长度调用出来
Stream.of(str.split(" "))
.filter(s -> s.length() > 2) // 参数是个Predicate，输入T，输出boolean
.map(s -> s.length()) // 参数是个Function， 输入T，输出R
.forEach(System.out::println); // 参数是个Consumer，消费者
// flatMap A->B属性(是个集合), 最终得到所有的A元素里面的所有B属性集合
// intStream/longStream 并不是Stream的子类, 所以要进行装箱 boxed
Stream.of(str.split(" "))
.flatMap(s -> s.chars().boxed()) // 参数是Function，
.forEach(i -> System.out.println((char) i.intValue()));
// peek 用于debug. 是个中间操作,和 forEach 是终止操作
System.out.println("--------------peek------------");
Stream.of(str.split(" "))
.peek(System.out::println) // 参数是个Consumer
.forEach(System.out::println);
// limit 使用, 主要用于无限流
new Random().ints().filter(i -> i > 100 && i < 1000).limit(10)
.forEach(System.out::println);
}四、stream终止操作
public static void main(String[] args) {
String str = "my name is 007";
// 使用并行流
str.chars().parallel().forEach(i -> System.out.print((char) i)); // 是乱序的
System.out.println();
// 使用 forEachOrdered 保证顺序
str.chars().parallel().forEachOrdered(i -> System.out.print((char) i));
// 收集到list
List<String> list = Stream.of(str.split(" "))
.collect(Collectors.toList());
System.out.println(list);
// 使用 reduce 拼接字符串
Optional<String> letters = Stream.of(str.split(" "))
.reduce((s1, s2) -> s1 + "|" + s2); // 参数是个BinaryOperator
System.out.println(letters.orElse(""));
// 带初始化值的reduce
String reduce = Stream.of(str.split(" ")).reduce("",
(s1, s2) -> s1 + "|" + s2);
System.out.println(reduce);
// 计算所有单词总长度
Integer length = Stream.of(str.split(" ")).map(s -> s.length())
.reduce(0, (s1, s2) -> s1 + s2);
System.out.println(length);
// max 的使用
Optional<String> max = Stream.of(str.split(" "))
.max((s1, s2) -> s1.length() - s2.length());
System.out.println(max.get());
// 使用 findFirst 短路操作
OptionalInt findFirst = new Random().ints().findFirst();
System.out.println(findFirst.getAsInt());
}五、并行流详解
因为stream惰性求值的特性，多次调用parallel / sequential, 以最后一次调用为准（主要是设置流中的并行状态，在终止操作执行时开始执行全部操作）。
public static void main(String[] args) {
// 调用parallel 产生一个并行流
// IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();
// 现在要实现一个这样的效果: 先并行,再串行
// 多次调用 parallel / sequential, 以最后一次调用为准.
// IntStream.range(1, 100)
// // 调用parallel产生并行流
// .parallel().peek(StreamDemo5::debug)
// // 调用sequential 产生串行流
// .sequential().peek(StreamDemo5::debug2)
// .count();
// 并行流使用的线程池，jdk自带的默认的: ForkJoinPool.commonPool
// 默认的线程数是 当前机器的cpu个数
// 使用这个属性可以修改默认的线程数
// System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism",
// "20");
// IntStream.range(1, 100).parallel().peek(StreamDemo5::debug).count();
// 使用自己的线程池, 不使用默认线程池, 防止任务被阻塞
// 线程名字 : ForkJoinPool-1
ForkJoinPool pool = new ForkJoinPool(20);
pool.submit(() -> IntStream.range(1, 100).parallel()
.peek(StreamDemo5::debug).count());
pool.shutdown();
synchronized (pool) {
try {
pool.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void debug(int i) {
System.out.println(Thread.currentThread().getName() + " debug " + i);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void debug2(int i) {
System.err.println("debug2 " + i);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}六、收集器
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import org.apache.commons.collections4.MapUtils;
/**
* 学生 对象
*/
class Student {
/**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age;
/**
* 性别
*/
private Gender gender;
/**
* 班级
*/
private Grade grade;
public Student(String name, int age, Gender gender, Grade grade) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.grade = grade;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
@Override
public String toString() {
return "[name=" + name + ", age=" + age + ", gender=" + gender
+ ", grade=" + grade + "]";
}
}
/**
* 性别
*/
enum Gender {
MALE, FEMALE
}
/**
* 班级
*/
enum Grade {
ONE, TWO, THREE, FOUR;
}
public class CollectDemo {
public static void main(String[] args) {
// 测试数据
List<Student> students = Arrays.asList(
new Student("小明", 10, Gender.MALE, Grade.ONE),
new Student("大明", 9, Gender.MALE, Grade.THREE),
new Student("小白", 8, Gender.FEMALE, Grade.TWO),
new Student("小黑", 13, Gender.FEMALE, Grade.FOUR),
new Student("小红", 7, Gender.FEMALE, Grade.THREE),
new Student("小黄", 13, Gender.MALE, Grade.ONE),
new Student("小青", 13, Gender.FEMALE, Grade.THREE),
new Student("小紫", 9, Gender.FEMALE, Grade.TWO),
new Student("小王", 6, Gender.MALE, Grade.ONE),
new Student("小李", 6, Gender.MALE, Grade.ONE),
new Student("小马", 14, Gender.FEMALE, Grade.FOUR),
new Student("小刘", 13, Gender.MALE, Grade.FOUR));
// 得到所有学生的年龄列表
// s -> s.getAge() --> Student::getAge , 不会多生成一个类似 lambda$0这样的函数
Set<Integer> ages = students.stream().map(Student::getAge)
.collect(Collectors.toCollection(TreeSet::new));
System.out.println("所有学生的年龄:" + ages);
// 统计汇总信息
// 年龄汇总信息:IntSummaryStatistics{count=12, sum=121, min=6, average=10.083333, max=14}
IntSummaryStatistics agesSummaryStatistics = students.stream()
.collect(Collectors.summarizingInt(Student::getAge));
System.out.println("年龄汇总信息:" + agesSummaryStatistics);
// 分块
Map<Boolean, List<Student>> genders = students.stream().collect(
Collectors.partitioningBy(s -> s.getGender() == Gender.MALE));
// System.out.println("男女学生列表:" + genders);
MapUtils.verbosePrint(System.out, "男女学生列表", genders);
// 分组
Map<Grade, List<Student>> grades = students.stream()
.collect(Collectors.groupingBy(Student::getGrade));
MapUtils.verbosePrint(System.out, "学生班级列表", grades);
// 得到所有班级学生的个数
Map<Grade, Long> gradesCount = students.stream().collect(Collectors
.groupingBy(Student::getGrade, Collectors.counting()));
MapUtils.verbosePrint(System.out, "班级学生个数列表", gradesCount);
}
}七、stream运行机制
1. 所有操作是链式调用, 一个元素只迭代一次
2. 每一个中间操作返回一个新的流. 流里面有一个属性sourceStage
指向同一个 地方,就是Head
3. Head->nextStage->nextStage->... -> null（实现方法的链式调用）
4. 有状态操作会把无状态操作截断,单独处理（有状态操作需要依赖于其他元素，无状态操作每个元素是独立的）
如下实例，sorted操作之前的peek、filter操作是并行执行的，到sorted的时候就会在peek、filter操作都执行完毕后再执行sorted操作，然后sorted操作执行完后执行后面的peek操作。
5. 并行环境下, 有状态的中间操作不一定能并行操作.
6. parallel/ sequetial 这2个操作也是中间操作(也是返回stream)
但是他们不创建流, 他们只修改 Head的并行标志
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
/**
* 验证stream运行机制
*
*/
public class RunStream {
public static void main(String[] args) {
Random random = new Random();
// 随机产生数据
Stream<Integer> stream = Stream.generate(() -> random.nextInt())
// 产生500个 ( 无限流需要短路操作. )
.limit(500)
// 第1个无状态操作
.peek(s -> print("peek: " + s))
// 第2个无状态操作
.filter(s -> {
print("filter: " + s);
return s > 1000000;
})
// 有状态操作
.sorted((i1, i2) -> {
print("排序: " + i1 + ", " + i2);
return i1.compareTo(i2);
})
// 又一个无状态操作
.peek(s -> {
print("peek2: " + s);
}).parallel();
// 终止操作
stream.count();
}
/**
* 打印日志并sleep 5 毫秒
*
* @param s
*/
public static void print(String s) {
// System.out.println(s);
// 带线程名(测试并行情况)
System.out.println(Thread.currentThread().getName() + " > " + s);
try {
TimeUnit.MILLISECONDS.sleep(5);
} catch (InterruptedException e) {
}
}
}
880
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
