jdk1.8笔记(2)-Stream流及方法引用

1. Stream流

在java8中，得益于Lambda所带来的函数式变成，引入一个***全新的Stream概念***，用于解决已有集合类库既有的弊端。

1.1 传统集合

1.1.1 传统集合操作多步遍历代码

/**
 * 用传统的方式，遍历集合，对集合中的元素进行过滤
 * 从集合中查询出以张开头且姓名长度为3的人，存储到一个新的集合中
 * @author kevin
 *
 */
public class TestList1 {

	public static void main(String[] args) {
		
		//创建一个List集合，存储姓名
		List<String> list = new ArrayList<>();
		list.add("张无忌");
		list.add("周芷若");
		list.add("赵敏");
		list.add("张强");
		list.add("张三丰");
		
		//对List集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
		List<String> listA = new ArrayList<>();
		for (String str : list) {
			if(str.startsWith("张")) {
				listA.add(str);
			}
		}
		
		//对listA集合进行过滤，只要姓名长度为3的人，存储到一个新的集合中
		List<String> listB = new ArrayList<>();
		for (String str : listA) {
			if(str.length() == 3) {
				listB.add(str);
			}
		}
		
		//打印输出listB集合
		for (String str : listB) {
			System.out.println(str);
		}

	}

}

输出结果为：

张无忌
张三丰

1.1.2 循环遍历的弊端

Java8的Lambda让我们可以更加专注于***做什么***（What），而不是***怎么做***（How）。

• for循环的语法就是“怎么做”
• for循环的循环体才是"做什么"

为什么使用循环？因为要进行遍历，但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而***并不是从第一个到最后一个顺序处理的循环***。前者是目的，后者是方式。

1.1.3 Stream的更优写法

/**
 * 使用Stream流的方式，遍历集合，对集合中的数据进行过滤
 * Stream流是JDK1.8之后出现的
 * 关注的是做什么，而不是怎么做
 * @author kevin
 *
 */
public class TestList2 {

	public static void main(String[] args) {
		
		//创建一个List集合，存储姓名
		List<String> list = new ArrayList<>();
		list.add("张无忌");
		list.add("周芷若");
		list.add("赵敏");
		list.add("张强");
		list.add("张三丰");
		
		list.stream()
		.filter(name -> name.startsWith("张"))
		.filter(name -> name.length() == 3)
		.forEach(name -> System.out.println(name));

	}

}

1.2 流式思想描述

类似于工厂车间的“生产流水线”

拼好一个“模型”步骤方案，然后再按照方案去执行它；方案就是一种“函数模型”。

而***模型***每一步都是一个***流***，调用指定的方法，可以从一个流模型转换为另一个流模型，直到最终步骤得到结果。

中间步骤对函数模型的操作，集合元素并没有被真正处理，只有当终结方法执行时候，整个模型才会按照指定策略执行操作，而这得益于Lambda的延迟执行特性。

“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列

• 元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源，可以是集合，数组等。

和以前的Collection操作不同，Stream操作还有两个基础的特征：

• Pipelining：中操作都会返回流对象本身，这样多个操作可以串联成一个管道，如图流式风格（fluent style），这样做可以操作进行优化，比如延迟执行（laziness）和短路（short-circuting）
• 内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式。显示的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）->数据转换->执行操作获取想要的结果，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

1.3 获取流

java.util.stream.Stream<T>是Java8新加入的最常用的流接口。（这并不是一个函数式接口）

有以下几种常用的方式获取流：

• 所有的Collection集合都可以通过stream默认方法获取流

default Stream<E> stream() {
    return StreamSupport.stream(spliterator(), false);
}

• Stream接口的静态方法of可以获取数组对应的流

@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

参数是一个可变参数，那么我们就可以传递一个数组

根据Collection获取流

根据Map获取流

根据数组获取流

例子：获取流Demo

public class TestGetStream {

	public static void main(String[] args) {
		//把集合转换为Stream流
		List<String> list = new ArrayList<>();
		Stream<String> streamList = list.stream();
		
		Set<String> set = new HashSet<>();
		Stream<String> streamSet = set.stream();
		
		Map<String, String> map = new HashMap<>();
		//获取键，存储到一个Set集合中
		Set<String> keySet = map.keySet();
		Stream<String> streamKeySet = keySet.stream();
		
		//获取值，存储到一个Collection集合中
		Collection<String> values = map.values();
		Stream<String> streamValues = values.stream();
		
		//获取键值对（键与值的映射关系 entrySet）
		Set<Map.Entry<String, String>> entries = map.entrySet();
		Stream<Map.Entry<String, String>> streamEntries = entries.stream();
		
		//将数组转换为Stream流
		Stream<Integer> stream = Stream.of(1,2,3,4,5);
		
		//可变参数可以传递数组
		Integer[] arr = {1,2,3,4,5};
		Stream<Integer> streamArr1 = Stream.of(arr);
		
		String[] arr1 = {"aaa","bbb","ccc"};
		Stream<String> streamArr2 = Stream.of(arr1);
		

	}

}

1.4 常用方法

流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分为两种：

[外链图片转存失败(img-nLd7wneM-1562089104671)(E:\学习整理\java\jdk1.8新特性\img\stream方法1.png)]

• 延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法）
• 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不能支持类似StringBuilder那样的链式调用。包括count和forEach方法等

1.4.1 逐一处理：forEach

void forEach(Consumer<? super T> action);

该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。

java.util.function.Consumer接口是一个消费型接口。

Consumer接口包含抽象方法void accept(T t)，意为消费一个指定泛型的数据。

例子：

/**
 * forEach方法用来遍历流中的数据
 * 是一个终结方法，遍历之后就不能继续使用Stream流中的其他方法
 * @author kevin
 *
 */
public class TestForEach {

	public static void main(String[] args) {
		//获取一个Stream流
		Stream<String> stream = Stream.of("Lily","Helena","Lucy","Simon");
		
		//使用Stream流中的forEach对Stream流中的数据进行遍历
		/*stream.forEach((String str) -> {
			System.out.println(str);
		});*/
		
		stream.forEach(str -> System.out.println(str));
	}

}

输出结果为：

Lily
Helena
Lucy
Simon

1.4.2 过滤：filter

可以通过filter方法将一个流转换成另一个子集流，方法签名：

Stream<T> filter(Predicate<? super T> predicate);

java.util.function.Predicate接口，其中唯一的抽象方法 boolean test(T t)，该方法会产生一个boolean值结果，代表指定的条件是否满足。如果结果为true，那么Stream流的filter方法将会留用元素；如果结果为false，那么filter方法将会舍弃元素。

例子：

public class TestFilter {

	public static void main(String[] args) {
		//创建一个Stream流
		Stream<String> stream = Stream.of("Lily","Helena","Lucy","Simon");
		
		//对Stream流中的元素进行过滤，只要以“L”开头的
		Stream<String> stream1 = stream.filter(str -> str.startsWith("L"));
		
		//遍历stream1流
		stream1.forEach(name -> System.out.println(name));
		
		/**
		 * Stream流属于管道流，只能被消息（使用）一次
		 * 第一个Stream流调用完毕方法，数据就会流转到下一个Stream上
		 * 而这时第一个Stream流已经使用完毕，就会关闭了
		 * 所以第一个Stream流就不能再调用方法了
		 * java.lang.IllegalStateException: stream has already been operated upon or closed
		 */
		//stream.forEach(name -> System.out.println(name));

	}

}

输出结果为：

Lily
Lucy

1.4.3 映射：map

将流中的元素映射到另外一个流中，方法签名为：

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

java.util.function.Function<T, R>接口

抽象方法 R apply(T t); 意为将一种T类型转换成R类型，而这种转换的操作，就成为“映射”

例子：

public class TestMap {
	
	public static void main(String[] args) {
		//获取一个String类型的Stream流
		Stream<String> stream = Stream.of("1","2","3","4");
		
		//使用map方法，将字符串类型的整数，转换（映射）为Integer类型的整数
		Stream<Integer> stream1 = stream.map((String str) -> {
			return Integer.parseInt(str);
		});
		
		//遍历Stream流
		stream1.forEach(i -> System.out.println(i));
	}
	
	

}

1.4.4 统计个数：count

如集合Collection中的size方法一样，流提供count方法来返回其中的元素个数：

long count();

该方法返回一个long值代表元素个数（不像集合Collection那样是int值）。

例子：

public class TestCount {

	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
		Stream<Integer> stream = list.stream();
		
		long count = stream.count();
		System.out.println(count);//7
		

	}

}

1.4.5 取用前几个：limit

limit方法可以对流进行截取，只取用前几个，方法签名：

Stream<T> limit(long maxSize);

参数是一个long类型，如果集合当前长度大于参数则进行截取；否则不进行操作。

例子：

public class TestLimit {

	public static void main(String[] args) {
		String[] arr = {"aaa","bbb","ccc","ddd","eee"};
		Stream<String> stream = Stream.of(arr);
		
		//使用limit对Stream流中的元素进行截取，只要前3个元素
		Stream<String> stream2 = stream.limit(3);
		
		stream2.forEach(str -> System.out.println(str));

	}

}

输出结果为：

aaa
bbb
ccc

1.4.6 跳过前几个：skip

如果需要跳过前n个元素，可以使用skip方法获取一个截取之后的新流：

Stream<T> skip(long n);

如果流的长度大于n，则跳过前n个；否则将会得到一个长度为0的空流。

例子：

public class TestSkip {
	
	public static void main(String[] args) {
		String[] arr = {"aaa","bbb","ccc","ddd","eee"};
		Stream<String> stream = Stream.of(arr);
		
		//使用skip方法跳过前3个元素
		Stream<String> stream2 = stream.skip(3);
		
		stream2.forEach(str -> System.out.println(str));

	}

}

输出结果为：

ddd
eee

1.4.7 组合：concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat:

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
    Objects.requireNonNull(a);
    Objects.requireNonNull(b);

    @SuppressWarnings("unchecked")
    Spliterator<T> split = new Streams.ConcatSpliterator.OfRef<>(
        (Spliterator<T>) a.spliterator(), (Spliterator<T>) b.spliterator());
    Stream<T> stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());
    return stream.onClose(Streams.composedClose(a, b));
}

备注：这是一个静态方法，与java.lang.String当中的concat方法是不同的。

例子：

public class TestConcat {

	public static void main(String[] args) {
		String[] arr = {"aaa","bbb","ccc","ddd","eee"};
		Stream<String> stream1 = Stream.of(arr);
		
		Stream<String> stream2 = Stream.of("Lily","Lucy","Helena","Simon");
		
		//把以上两个流组合为一个流
		Stream<String> stream = Stream.concat(stream1, stream2);
		
		//遍历concat流
		stream.forEach(str -> System.out.println(str));

	}

}

输出结果为：

aaa
bbb
ccc
ddd
eee
Lily
Lucy
Helena
Simon

2. 方法引用

在使用Lambda表达式的时候，我们实际上传进去的代码就是一种解决方案：拿什么参数进行什么操作。

如果已有地方存在相同的操作方案，这样就会导致重复写。可以使用方法引用来优化。

例子：

• 函数式接口 Printable.java

@FunctionalInterface
public interface Printable {
	
	void print(String s);

}

• 测试类 TestPrintable.java

public class TestPrintable {
	
	public static void printString(Printable p) {
		p.print("Hello World");
	}

	public static void main(String[] args) {
		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);

	}

}

输出结果为：

Hello World
Hello World

2.1 方法引用符

双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

2.2 通过对象名引用成员方法

• 函数式接口 Printable.java

@FunctionalInterface
public interface Printable {
	
	void print(String s);

}

• MethodRerObject.java

public class MethodRerObject {
	//定义一个成员方法，传递字符串，把字符串按照大写输出
	public void printUpperCaseString(String str) {
		System.out.println(str.toUpperCase());
	}

}

• 测试类 TestPrintable2.java

/**
 * 通过对象名引用成员方法
 * 使用前提是对象名是已经存在的，成员方法也是已经存在
 * 就可以使用对象名来引用成员方法
 * @author kevin
 *
 */
public class TestPrintable2 {
	//定义一个方法，方法的参数传递Printable接口
	public static void printString(Printable p) {
		p.print("Hello World");
	}

	public static void main(String[] args) {
		//调用printString方法，方法的参数Printable是一个函数式接口，所以可以传递Lambda表达式
		printString((s) -> {
			//创建MethodRerObject对象
			MethodRerObject m = new MethodRerObject();
			//调用MethodRerObject对象中的成员方法printUpperCaseString，把字符串按照大写输出
			m.printUpperCaseString(s);
		});
		
		/*
		 * 使用方法引用优化Lambda
		 * 对象是已经存在的MethodRerObject
		 * 成员方法也是已经存在的printUpperCaseString
		 * 所以我们可以使用对象名引用成员方法
		 */
		//创建MethodRerObject对象
		MethodRerObject m = new MethodRerObject();
		printString(m :: printUpperCaseString);

	}

}

输出结果为：

HELLO WORLD
HELLO WORLD

2.3 通过类名称引用静态方法

• 函数式接口 Calcable.java

@FunctionalInterface
public interface Calcable {
	//定义一个抽象方法，传递一个整数，对整数进行绝对值计算并返回
	int calsAbs(int number);

}

• 测试类 TestStaticMethodReference.java

/**
 * 通过类名称引用静态方法
 * 类已经存在，静态成员方法也已经存在
 * 就可以通过类名直接引用静态成员方法
 * @author kevin
 *
 */
public class TestStaticMethodReference {
	//定义一个方法，方法的参数传递要计算绝对值的整数和函数式接口Calcable
	public static int method(int number, Calcable c) {
		return c.calsAbs(number);
	}

	public static void main(String[] args) {
		//调用method方法，传递计算绝对值的整数和Lambda表达式
		int number = method(-10, (n) -> {
			//对参数进行绝对值计算并返回结果
			return Math.abs(n);
		});
		
		System.out.println(number);
		
		/*
		 * 使用方法引用优化Lambda表达式
		 * Math类是存在的
		 * abs计算绝对值的静态方法也是已经存在的
		 * 所以我们可以直接通过类名引用静态方法
		 */
		int number2 = method(-10, Math :: abs);
		System.out.println(number2);

	}

}

输出结果为：

10
10

2.4 通过super引用成员方法

如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。

• 函数式接口 Greetable.java

/*
 * 定义见面的函数式接口
 */
@FunctionalInterface
public interface Greetable {
	//定义一个见面的方法
	void greet();

}

• 父类 Human.java

/*
 * 定义父类
 */
public class Human {
	//定义一个sayHello的方法
	public void sayHello() {
		System.out.println("Hello 我是Human");
	}

}

• 测试类 Man.java

/**
 * 通过Super引用成员方法
 * @author kevin
 *
 */
public class Man extends Human {
	//子类重写父类sayHello的方法
	@Override
	public void sayHello() {
		System.out.println("Hello,我是Man!");
	}
	
	//定义一个方法参数传递Greetable接口
	public void method(Greetable g) {
		g.greet();
	}
	
	public void show() {
		//调用method方法
		/*method(() -> {
			Human h = new Human();
			h.sayHello();
		});*/
		
		/*method(() -> {
			super.sayHello();
		});*/
		
        /*
		 * 使用super引用类的成员方法
		 * super是已经存在的
		 * 父类的成员方法sayHello也是已经存在的
		 * 所以我们可以直接使用super引用弗雷德成员方法
		 */
		method(super :: sayHello);
	}

	public static void main(String[] args) {
		
		new Man().show();

	}

}

输出结果为：

Hello 我是Human

2.5 通过this引用成员方法

this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用“this::成员方法”的各式来使用方法引用。

• 函数式接口 Richable.java

/*
 * 定义一个富有的函数式接口
 */
@FunctionalInterface
public interface Richable {
	//定义一个想买什么就买什么的方法
	void buy();

}

• 测试类 Husband.java

/**
 * 通过this引用本类的成员方法
 * @author kevin
 *
 */
public class Husband {
	//定义一个买房子的方法
	public void buyHouse() {
		System.out.println("北京二环内买一套四合院！");
	}
	
	//定义一个结婚的方法，参数传递Richable接口
	public void marry(Richable r) {
		r.buy();
	}
	
	//定义一个非常高兴的方法
	public void soHappy() {
		//调用结婚的方法，方法的参数Richable是一个函数式接口，传递Lambda表达式
		/*marry(() -> {
			this.buyHouse();
		});*/
		
		/*
		 * 使用方法引用优化Lambda表达式
		 * this是已经存在的
		 * 本类的成员方法buyHouse也是已经存在的
		 * 所以我们可以直接使用this引用本类的成员方法buyHouse
		 */
		marry(this :: buyHouse);
	}

	public static void main(String[] args) {
		new Husband().soHappy();

	}

}

输出结果为：

北京二环内买一套四合院！

2.6 类的构造器引用

由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new的格式表示。

• Person.java

public class Person {
	
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public Person() {
		super();
	}
	
	

}

• 函数式接口 PersonBuilder.java

/*
 * 定义一个创建Person对象的函数式接口
 */
@FunctionalInterface
public interface PersonBuilder {
	//定义一个方法，根据传递的姓名，创建Person对象返回
	Person builderPerson(String name);

}

• 测试类 Demo.java

/**
 * 类的构造器（构造方法）引用
 * @author kevin
 *
 */
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表达式
		 * 构造方法new Person(String name)已知
		 * 创建对象已知 new
		 * 就可以使用Person引用new创建对象
		 */
		printName("古力娜扎", Person :: new);

	}

}

输出结果为：

迪丽热巴
古力娜扎

2.7 数组的构造器引用

数组也是object的子类对象，所以同样具有构造器，只是语法稍微不同。

• 函数式接口 ArrayBuilder.java

/*
 * 定义一个创建数组的函数式接口
 */
@FunctionalInterface
public interface ArrayBuilder {
	//定义一个创建int类型数组的方法，参数传递数组的长度，返回创建好的int类型数组
	int[] builderArray(int length);

}

• 测试类 Demo.java

/*
 * 数组的构造器引用
 */
public class Demo {
	
	/*
	 * 定义一个方法
	 * 方法的参数传递创建数组的长度和ArrayBuilder接口
	 * 方法的内部根据传递的长度使用ArrayBuilder中的方法创建数组并返回
	 */
	public static int[] createArray(int length, ArrayBuilder ab) {
		return ab.builderArray(length);
	}

	public static void main(String[] args) {
		//调用createArray方法，传递数组的长度和Lambda表达式
		int[] arr1 = createArray(10, (len) -> {
			//根据数组的长度，创建数组并返回
			return new int[len];
		});
		
		System.out.println(arr1.length);
		
		
		/*
		 * 使用方法引用优化Lambda表达式
		 * 已知创建的就是int[]数组
		 * 数组的长度是已知的
		 * 就可以使用方法引用
		 * int[]引用new,根据参数传递的长度来创建数组
		 */
		int[] arr2 = createArray(10, int[] :: new);
		System.out.println(Arrays.toString(arr2));
		System.out.println(arr2.length);

	}

}

输出结果为：

10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
10