Stream流
Stream流
第一章 Stream流
在Java8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
1.1 引言
传统集合的多步遍历代码
import java.util.ArrayList;
/*
使用传统方式，遍历集合，对集合中的数据进行过滤。
*/
public class Demo1List {
public static void main(String[] args) {
//创建一个List集合，存储姓名
ArrayList<String> list = new ArrayList<>();
//添加元素
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张飞");
list.add("张三丰");
//对集合中的元素进行遍历，只要以张开头的元素，存储在新的集合中
ArrayList<String> listA = new ArrayList<>();
for(String s : list){
//判断是否以'张'开头
if(s.startsWith("张")){
listA.add(s); //是 就存储到listA集合中
}
}
//对listA集合进行过滤：只要姓名长度为3的人，存储到新的集合中
ArrayList<String> listB = new ArrayList<>();
for (String s : listA) {
//判断姓名长度是否为3
if(s.length() == 3){
listB.add(s); //是 存储到listB集合中
}
}
//遍历listB集合
for (String s : listB) {
System.out.println(s);
}
}
}
循环遍历的弊端
代码冗长，循环不能重复使用，效率低，占用更多的资源！
Stream的更优写法
import java.util.ArrayList;
import java.util.Collections;
/*
使用Stream流的方式，遍历集合，对集合中的数据进行过滤。
Stream流是JDK1.8之后出现的
关注的是做什么，而不是怎么做！
*/
public class Demo2List {
public static void main(String[] args) {
//创建一个List集合，存储姓名
ArrayList<String> list = new ArrayList<>();
//添加元素
Collections.addAll(list,"张无忌","周芷若","赵敏","张飞","张三丰");
//对集合中的元素进行遍历：只要以张开头的元素，存储在新的集合中
//对listA集合进行过滤：只要姓名长度为3的人，存储到新的集合中
//遍历listB集合
list.stream().filter(name -> name.startsWith("张"))
.filter(name -> name.length() == 3)
.forEach(name -> System.out.println(name));
}
}
1.2 流式思想概述
流式思想示意图：
1.3 获取流
import java.util.*;
import java.util.stream.Stream;
/*
java.util.stream.Stream<T>是Java 8新加入的最常用的流接口。（这并不是一个函数式接口）
获取流的两种方式：
- 所有的Collection集合都可以通过Stream默认方法获取流；
default Stream<E> stream(); 返回一个顺序Stream于此集合作为其来源。
- Stream<T> 接口的静态方法of可以获取数组对应的流
static <T> Stream<T> of(T... values); 返回其元素是指定值的顺序排序流。
参数是一个可变参数，可以传递一个数组。
*/
public class Demo1GetStream {
public static void main(String[] args) {
//把集合转换成Stream流：
ArrayList<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
Map<String,String> map = new HashMap<>();
//keySet()：获取键,存储到Set集合中
Set<String> keyset = map.keySet();
Stream<String> stream3 = keyset.stream();
//values()：获取值，存储到Collection集合中
Collection<String> coll = map.values();
Stream<String> stream4 = coll.stream();
//entrySet(): 获取键值对（键与值的映射关系 entrySet）
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String,String>> stream5 = entries.stream();
//把数组转换为Stream流：
Stream<Integer> stream6 = Stream.of(1,2,6,4,7);
Integer[] arr1 = {9,5,6,8,23};
Stream<Integer> stream7 = Stream.of(arr1);
String[] arr2 = {"Durant","James","Harden","Curry"};
Stream<String> stream8 = Stream.of(arr2);
}
}
1.4 常用方法
逐一处理：forEach
import java.util.stream.Stream;
/*
Stream流中的常用方法forEach:
void forEach(Consumer<? super T> action); 对此流的每个元素执行操作。
该方法接受一个Consumer接口函数，会将每一个流元素交给该函数进行处理。
Consumer接口是一个消费型的函数式接口，可以传递Lambda表达式消费数据
简单记：
forEach(); 用来遍历流中的数据
是一个终结方法，遍历之后就不能继续调用Stream流中的其它方法。
*/
public class Demo2Stream_forEach {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("杜兰特","詹姆斯","汤普森","欧文");
/*stream.forEach((String name) -> {
System.out.println(name);
});*/
//优化Lambda：
stream.forEach(name -> System.out.println(name));
}
}
过滤：filter
import java.util.stream.Stream;
/*
Stream流中的常用方法filter：
Stream<T> filter(Predicate<? super T> predicate); 返回由与此给定谓词匹配的此流的元素组成的流。
filter方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
Predicate中的抽象方法：
boolean test(T t);
*/
public class Demo3Stream_filter {
public static void main(String[] args) {
//创建一个Stream流
Stream<String> stream = Stream.of("陈独秀","李大钊","李星华","胡适","辜鸿略","李鸿章");
//对Stream流中的元素进行过滤，只要姓李的人
Stream<String> stream2 = stream.filter(name -> name.startsWith("李"));
//遍历stream2流
stream2.forEach(name -> System.out.println(name));
/*
Stream流属于管道流，只能被消费/使用一次。
第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这时第一个Stream流已经使用完，关闭了；
所以第一个Stream流就不能再调用方法。
IllegalStateException: stream has already been operated upon or closed!
*/
//遍历stream流：
//stream.forEach(name -> System.out.println(name));
}
}
映射：map
import java.util.stream.Stream;
/*
如果需要将流中的元素映射到另一个流中，可以使用map方法：
<R> Stream<R> map(Function<? super T,? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流。
Function中的抽象方法：
R apply(T t);
*/
public class Demo4Stream_map {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("5","4","8","29");
//使用map()：把字符串类型的整数，转换/映射为Integer类型的整数
Stream<Integer> stream2 = stream.map((String s) -> {
return Integer.parseInt(s);
});
//遍历stream
stream2.forEach(name -> System.out.println(name));
}
}
统计个数：count
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
/*
Stream流中的常用方法count：用于统计Stream流中元素的个数
long count();
count(); 是一个终结方法，返回值是一个long类型的整数，所以不能再继续调用Stream流中的其它方法了。
*/
public class Demo5Stream_count {
public static void main(String[] args) {
//获取一个Stream流
ArrayList<Integer> list = new ArrayList<>();
//添加元素
Collections.addAll(list,9,5,6,8,2,3);
Stream<Integer> stream = list.stream();
System.out.println(stream.count()); //6
}
}
取用前几个：limit
import java.util.stream.Stream;
/*
Stream流中的常用方法limit：用于截取流中的元素
limit()可以对流进行截取，只取用前n个：
Stream<T> limit(long maxsize);
参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
limit()是一个延迟方法，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其它方法。
*/
public class Demo6Stream_limit {
public static void main(String[] args) {
//获取一个Steam流
Stream<String> stream = Stream.of("陈独秀","李大钊","鲁迅","钱玄同","胡适","辜鸿略");
//limit(): 截取前4个元素
Stream<String> stream2 = stream.limit(4);
//遍历stream2
stream2.forEach(name -> System.out.println(name));
}
}
跳过前几个：skip
import java.util.stream.Stream;
/*
Stream流中的常用方法skip：用于跳过元素
如果希望跳过前几个元素，可以使用skip方法获取一个截取之后的新流：
Stream<T> skip(long n);
如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。
*/
public class Demo7Stream_skip {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("赵世炎","陈延年","柳眉","陈乔年","郭心刚");
//skip(long n)：跳过前n个
Stream<String> stream2 = stream.skip(3);
//遍历stream2
stream2.forEach(name -> System.out.println(name));
}
}
组合：concat
import java.util.stream.Stream;
/*
Stream流中的常用方法concat：用于把流组合到一起
如果有两个流，希望合并成一个流，可以使用Stream接口中的静态方法concat
static <T> stream<T> concat(Stream<? extends T> a,Stream<? extends T> b);
*/
public class Demo8Stream_concat {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream1 = Stream.of("杜兰特","詹姆斯","汤普森","乔治");
//获取一个Stream流
Stream<String> stream2 = Stream.of("KD","LBJ","KT","PG");
//concat();
Stream<String> stream3 = Stream.concat(stream1,stream2);
stream3.forEach(name -> System.out.println(name));
}
}
1.5 练习：集合元素处理
package day12.stream.demo3Stream;
//定义一个Person类：
public class Person {
private String name;
public Person(){
}
public Person(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public String toString(){
return "Person{name='" + name + "\'" + "}";
}
}
package day12.stream.demo3Stream;
import java.util.ArrayList;
/*
练习：
现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用传统的for循环(或增强for循环)依次进行
一下若干操作步骤：
1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
4.第二个队伍筛选之后不要前2个人，存储到一个新集合中
5.将两个队伍合并成一个队伍，存储到一个新集合中
6.根据姓名创建Person对象，存储到一个新集合中
7.打印整个Person对象信息
*/
// ①传统方式：处理集合元素。
public class Demo1StreamTest {
public static void main(String[] args) {
//第一支队五
ArrayList<String> list1 = new ArrayList<>();
list1.add("迪丽热巴");
list1.add("宋远桥");
list1.add("苏星河");
list1.add("石破天");
list1.add("石中玉");
list1.add("老子");
list1.add("庄子");
list1.add("洪七公");
//1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
ArrayList<String> one = new ArrayList<>();
for(String name : list1){
if(name.length() == 3){
one.add(name);
}
}
//2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
ArrayList<String> two = new ArrayList<>();
for(int i = 0;i < 3;i++){
two.add(one.get(i));
}
//第二支队伍
ArrayList<String> list2 = new ArrayList<>();
list2.add("古力娜扎");
list2.add("张无忌");
list2.add("赵丽颖");
list2.add("张三丰");
list2.add("尼古拉斯赵四");
list2.add("张天爱");
list2.add("张二狗");
//3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
ArrayList<String> three = new ArrayList<>();
for(String name : list2){
if(name.startsWith("张")){
three.add(name);
}
}
//4.第二个队伍筛选之后不要前2个人，存储到一个新集合中
ArrayList<String> four = new ArrayList<>();
/*three.remove(0);
three.remove(1);
four = three;*/
for(int i = 2;i < three.size();i++){
four.add(three.get(i)); //i 不包含0 1
}
//5.将两个队伍合并成一个队伍，存储到一个新集合中
ArrayList<String> all = new ArrayList<>();
all.addAll(two);
all.addAll(four);
//6.根据姓名创建Person对象，存储到一个新集合中
ArrayList<Person> list = new ArrayList<>();
for (String name : all) {
list.add(new Person(name));
}
//7.打印整个Person对象信息
for(Person p : list){
System.out.println(p);
}
}
}
② 使用Stream流：
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Stream;
/*
使用Stream流的方式对上一题的传统for循环优化：
*/
public class Demo2StreamTest {
public static void main(String[] args) {
//第一支队五
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"迪丽热巴","宋远桥","苏星河","石破天","石中玉","老子","庄子","洪七公");
//1.第一个队伍只要名字为3个字的成员姓名，存储到一个新集合中
//2.第一个队伍筛选之后只要前3个人，存储到一个新集合中
Stream<String> stream1 = list1.stream().filter(name -> name.length() == 3).limit(3);
//第二支队伍
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"古力娜扎","张无忌","赵丽颖","张三丰","尼古拉斯赵四","张天爱","张二狗");
//3.第二个队伍只要姓张的成员姓名，存储到一个新集合中
//4.第二个队伍筛选之后不要前2个人，存储到一个新集合中
Stream<String> stream2 = list2.stream().filter(name -> name.startsWith("张")).skip(2);
//5.将两个队伍合并成一个队伍，存储到一个新集合中
//6.根据姓名创建Person对象，存储到一个新集合中
//7.打印整个Person对象信息
Stream.concat(stream1,stream2).map(name -> new Person(name)).forEach(p -> System.out.println(p));
}
}
第二章 方法引用
2.1 方法引用符
//定义一个打印的函数式接口:
@FunctionalInterface
public interface Printable {
//定义字符串的抽象方法
void print(String s);
}
//定义类：
public class Demo1Printable {
//定义一个方法：参数传递Printable接口，对字符串进行打印
public static void printString(Printable p){
p.print("陈独秀");
}
public static void main(String[] args) {
//调用printString(Printable p): 参数是一个函数式接口，可以使用Lambda表达式
printString(s -> System.out.println(s));
/*
分析：
Lambda表达式的目的：打印参数传递的字符串
把参数s传递给了System.out对象，调用out对象中的方法println对字符串进行输出
注意：
1.System.out对象是已经存在的
2.println()也是已经存在的
因此，可以使用方法引用来优化Lambda表达式：
直接使用System.out方法直接引用/调用println方法。
*/
printString(System.out::println);
}
}
2.2 通过对象名引用成员方法
package day12.stream.demo5ObjectMethodReference;
public class MethodReObject {
//定义一个成员方法：传递字符串，把字符串按照大写输出
public void printUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
}
package day12.stream.demo5ObjectMethodReference;
//定义一个打印的函数式接口
@FunctionalInterface
public interface Printable {
//定义字符串的抽象方法
void print(String s);
}
package day12.stream.demo5ObjectMethodReference;
/*
通过对象名引用成员方法：
使用前提是：对象名已经存在，成员方法也已经存在。
*/
public class Demo1ObjectMethodReference {
//定义一个方法：方法的参数传递Printable接口
public static void printString(Printable p){
p.print("Hello");
}
public static void main(String[] args) {
//调用printString(): 方法的参数Printable是一个函数式接口，可以传递Lambda表达式
printString((String s) -> {
//创建MethodReObject对象
MethodReObject mrj = new MethodReObject();
//调用MethodReObject对象中的成员方法printUpperCaseString,把字符串按照大写输出
mrj.printUpperCaseString(s);
});
/*
使用方法引用优化Lambda;
对象是已经存在的MethodReObject;
成员方法也是已经存在的PrintUpperCaseString
可使用对象名引用成员方法。
*/
printString(new MethodReObject()::printUpperCaseString);
}
}
2.3 通过类名称引用静态方法
package day12.stream.demo6StaticMethodReference;
@FunctionalInterface
public interface Calcable {
//定义一个抽象方法：传递一个整数，对整数进行绝对值计算并返回
int calsAbs(int number);
}
package day12.stream.demo6StaticMethodReference;
/*
通过类名引用静态成员方法：
类已经存在，静态成员方法也已经存在，就可以通过类名直接引用静态成员方法。
*/
public class Demo1StaticMethodReference {
//定义一个方法：方法的 参数传递要计算绝对值的整数，和函数式接口Calcable
public static int method(int number,Calcable c){
return c.calsAbs(number);
}
public static void main(String[] args) {
//调用method(): 传递计算绝对值的整数和Lambda表达式
/*int number = method(-26,(int n) -> {
//对参数进行绝对值计算并返回结果
return Math.abs(n);
});*/
int number = method(-26,n -> Math.abs(n));
System.out.println(number);
/*
使用方法引用优化Lambda：
Math类是存在的；
abs();计算绝对值的静态方法也是已经存在的；
可直接通过类名引用静态方法。
*/
int result = method(-26, Math::abs);
System.out.println(result);
}
}
2.4 通过super引用成员方法
package day12.stream.demo7demo7SuperMethodReference;
//定义见面的函数式接口：
public interface Greetable {
//定义一个见面的方法
void greet();
}
package day12.stream.demo7demo7SuperMethodReference;
//定义父类：
public class Human {
//定义一个sayHello方法
public void sayHello(){
System.out.println("Hello,我是Human！");
}
}
package day12.stream.demo7demo7SuperMethodReference;
//定义子类：
public class Man extends Human{
//子类重写父类的sayHello();
public void sayHello(){
System.out.println("Hello,我是Man！");
}
//定义一个方法：参数传递Greetable接口
public void method(Greetable g){
g.greet();
}
public void show(){
//调用method(): 方法的参数Greetable是一个函数式接口，可用Lambda传递
/*method(() -> {
//创建父类Human对象
Human h = new Human();
//调用父类的sayHello()
h.sayHello();
});*/
//因为有子父类关系，关键字super：代表父类；通过super引用父类的成员方法。
method(super::sayHello);
}
public static void main(String[] args) {
new Man().show();
}
}
2.5 通过this引用成员方法
package day12.stream.demo8ThisMethodReference;
//定义一个 富有的 函数式接口:
@FunctionalInterface
public interface Richable {
//定义一个买东西的方法
void buy();
}
package day12.stream.demo8ThisMethodReference;
/*
通过this引用本类的成员方法：
*/
public class Husband {
//定义一个买房子的方法
public void buyHouse(){
System.out.println("北京二环内整一套四合院！");
}
//定义一个结婚的方法,参数传递Richable接口
public void marry(Richable r){
r.buy();
}
//定义一个非常高兴的方法
public void soHappy(){
//调用结婚的方法：方法的参数Richable是一个函数式接口，可传递Lambda表达式
/* marry(() -> {
//使用this.成员方法，调用本类买房子的方法
this.buyHouse();
});*/
/*
使用方法引用优化Lambda:
this是已经存在的；
本类的成员方法buyHouse也是已经存在的；
可用this引用本类的成员方法buyHouse。
*/
marry(this::buyHouse);
}
public static void main(String[] args) {
new Husband().soHappy();
}
}
2.6 类的构造器引用
package day12.stream.demo9ConstructorMethodReference;
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package day12.stream.demo9ConstructorMethodReference;
/*
定义一个创建Person对象的函数式接口
*/
@FunctionalInterface
public interface PersonBuilder {
//定义一个方法：根据传递的姓名，创建Person对象并返回
Person builderPerson(String name);
}
package day12.stream.demo9ConstructorMethodReference;
//类的构造器引用：
public class Demo {
//定义一个方法：参数传递姓名和PersonBuilder接口，方法中通过姓名创建Person对象
public static void printName(String name,PersonBuilder pb){
Person person = pb.builderPerson(name);
System.out.println(person.getName());
}
public static void main(String[] args) {
//调用PrintName(): 参数传递的是PersonBuilder接口是一个函数式接口，可传递Lambda
printName("陈都灵",(String name) -> {
return new Person(name);
});
/*
使用方法引用优化Lambda：
构造方法Person(String name)已经存在；
创建对象已知 new；
可用Person引用new创建对象
*/
printName("陈妍希",Person::new); //使用Person类的带参构造方法，通过传递的姓名创建对象。
}
}
2.7 数组的构造器引用
package day12.stream.demo10ArrayMethodReference;
/*
定义一个创建数组的函数式接口
*/
@FunctionalInterface
public interface ArrayBuilder {
//定义一个创建int[]的方法，参数传递数组的长度，返回创建好的数组
int[] buildArray(int length);
}
package day12.stream.demo10ArrayMethodReference;
import java.util.Arrays;
/*
数组构造器的引用：
*/
public class Demo {
/*
定义一个方法：
方法的参数传递创建数组的长度和ArrayBuilder接口
方法内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
*/
public static int[] createArray(int length,ArrayBuilder ab){
return ab.buildArray(length);
}
public static void main(String[] args) {
//调用createArray(): 参数传递数组的长度和Lambda表达式
int[] array = createArray(8, (int len) -> {
return new int[len];
});
System.out.println(array.length);
/*
使用方法引用优化Lambda：
已知创建的就是int[]数组
数组的长度也是已知的
可使用方法引用：int[]引用new，根据参数传递的长度来创建数组。
*/
int[] array1 = createArray(10, int[]::new);
System.out.println(Arrays.toString(array1));
System.out.println(array1.length);
}
}
浙公网安备 33010602011771号