初次学习Stream流的学习笔记,学习之前先了解一下函数式接口
API是一个程序向使用者提供的一些方法,通过这些方法就能实现某些功能.所以对于流API来
说,重点是怎么理解"流"这个概念,所谓的流:就是数据的渠道,所以,流代表的是一个对象的
序列.它和Java I/O类里使用的"流"不同.虽然在概念上与java.util.stream中定义的流是类
似的,但它们是不同的.流API中的流是描述某个流类型的对象.
流API中的流操作的数据源,是数组或者是集合.它本身是不存储数据的,只是移动数据,在移动
过程中可能会对数据进行过滤,排序或者其它操作.但是,一般情况下(绝大数情况下),流操作
本身不会修改数据源.比如,对流排序不会修改数据源的顺序.相反,它会创建一个新的流,其
中包含排序后的结果.
“Stream流”其实是一个集合元素的函数模型,它并不是集合,也不是数据结构,其本身并不存储任何
元素(或其地址值)。
Stream(流)是一个来自数据源的元素队列
和以前的Collection操作不同, Stream操作还有两个基础的特征:
当使用一个流的时候,通常包括三个基本步骤:获取一个数据源(source)→ 数据转换→执行操作获取想要的结
果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以
像链条一样排列,变成一个管道。
java.util.stream.Stream
获取一个流非常简单,有以下几种常用的方式:
static
可以看出,Stream流是与容器相关的.
下面例子演示如何获取Stream流:
package com.wzlove.stream.demo2;
import java.util.*;
import java.util.stream.Stream;
/**
* @创建人 王智
* @创建时间 2018/7/28
* @描述 演示获取Stream流
*/
public class ConvertStream {
public static void main(String[] args) {
// 单列集合根据Collection的stream方法获取流
// 数组集合
ArrayList<String> arrayList = new ArrayList<>();
Stream<String> stream1 = arrayList.stream();
// set集合
Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();
// Map集合不能直接转化为Stream流,但是可以先将Map集合转化为Set集合
Map<String,String> map = new HashMap<>();
// map集合转化为Set集合再转化为Stream流
Stream<String> stream3 = map.keySet().stream();
Stream<String> stream4 = map.values().stream();
Stream<Map.Entry<String, String>> stream5 = map.entrySet().stream();
// 使用第二种方式获取Stream流
// 传递数组
Stream<int[]> stream6 = Stream.of(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9});
// 传入可变参数
Stream<Integer> stream7 = Stream.of(1, 2, 3, 4, 5, 6);
}
}
流模型的操作很丰富,这里介绍一些常用的API。这些方法可以被分成两种:
注意 : Stream流只能被使用一次,再次使用会抛出异常,说流已经关闭.
方法不一一演示,最后统一演示:
终结方法,遍历之后就不能再调用Stream流中的其他方法
也是一个终结方法
备注:这是一个静态方法,与java.lang.String 当中的concat 方法是不同的。
演示前几个常用方法:
package com.wzlove.stream.demo2;
import java.util.ArrayList;
/**
* @创建人 王智
* @创建时间 2018/7/28
* @描述 测试Stream流的常用方法
*/
public class StreamUsuallyMethod {
public static void main(String[] args) {
// 准备数据
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(5);
arrayList.add(3);
arrayList.add(9);
arrayList.add(1);
arrayList.add(4);
arrayList.add(2);
arrayList.add(3);
arrayList.add(6);
arrayList.add(8);
arrayList.add(7);
// 测试Stream的forEach方法
System.out.print("forEach方法的测试 : ");
arrayList.stream().forEach(elem -> System.out.print(elem + " "));
System.out.println();
// 测试Filter方法
// 获取集合中大于5的数字
System.out.print("获取集合中大于5的数字 : ");
arrayList.stream().filter(elem -> elem > 5).forEach(elem -> System.out.print(elem + " "));
System.out.println();
// 获取集合中大于2小于7的数字
System.out.print("获取集合中大于2小于7的数字 : ");
arrayList.stream().filter(elem -> elem > 2).filter(elem -> elem < 7).forEach(elem -> System.out.print(elem + " "));
System.out.println();
// 测试Map方法
// 将集合转化为String集合
System.out.print("map方法将int转化为String : ");
arrayList.stream().map(elem -> String.valueOf(elem)).forEach(elem -> System.out.print(elem + " "));
System.out.println();
}
}
举个例子,使用所有的常用方法:
package com.wzlove.stream.demo2;
import java.util.ArrayList;
import java.util.stream.Stream;
/**
* @author 王智
* @date 2018/7/28
* @描述
* 1. 第一个队伍只要名字为3个字的成员姓名;存储到一个新集合中。
* 2. 第一个队伍筛选之后只要前3个人;存储到一个新集合中。
* 3. 第二个队伍只要姓张的成员姓名;存储到一个新集合中。
* 4. 第二个队伍筛选之后不要前2个人;存储到一个新集合中。
* 5. 将两个队伍合并为一个队伍;存储到一个新集合中。
* 6. 根据姓名创建Person 对象;存储到一个新集合中。
* 7. 打印整个队伍的Person对象信息。
*/
public class StreamDemo {
public static void main(String[] args) {
//第一支队伍
ArrayList<String> one = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
//第二支队伍
ArrayList<String> two = new ArrayList<>();
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
/*
* 1. 第一个队伍只要名字为3个字的成员姓名;存储到一个新集合中。
* 2. 第一个队伍筛选之后只要前3个人;存储到一个新集合中。
* 3. 第二个队伍只要姓张的成员姓名;存储到一个新集合中。
* 4. 第二个队伍筛选之后不要前2个人;存储到一个新集合中。
* 5. 将两个队伍合并为一个队伍;存储到一个新集合中。
* 6. 根据姓名创建Person 对象;存储到一个新集合中。
* 7. 打印整个队伍的Person对象信息。
*/
// 直接使用Stream流来完成
Stream.concat(
one.stream().filter(elem -> elem.length() == 3).limit(3),
two.stream().filter(elem -> elem.startsWith("张")).skip(2))
.map(elem -> new Person(elem))
.forEach(elem -> System.out.println(elem));
}
}
很少使用
:: 写法就是方法的引用,它的出现是为了简化Lambda的写法.
System.out 对象中有一个重载的println(String) 方法恰好就是我们所需要的。那么对于
printString 方法的函数式接口参数,对比下面两种写法,完全等效:
第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println 方法去处理。
第二种等效写法的语义是指:直接让System.out 中的println 方法来取代Lambda。两种写法的执行效果完全一
样,而第二种方法引用的写法复用了已有方案,更加简洁。
注:Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常
类型有
这些很少用,是要能看懂就行
通过对象名引用成员方法(demo1)
package com.wzlove.method.demo1;
/*
定义一个打印的函数式接口
*/
@FunctionalInterface
public interface Printable {
//定义字符串的抽象方法
void print(String s);
}
package com.wzlove.method.demo1;
public class MethodRerObject {
//定义一个成员方法,传递字符串,把字符串按照大写输出
public void printUpperCaseString(String str){
System.out.println(str.toUpperCase());
}
}
package com.wzlove.method.demo1;
/**
* @author 王智
* @date 2018/7/28
* @描述 使用方法引用简化Lambda表达式,对象调用方法
*/
public class Demo1 {
public static void printString(Printable printable){
printable.print("java");
}
public static void main(String[] args) {
// 简化前的写法
printString(s->{
// 创建对象
MethodRerObject methodRerObject = new MethodRerObject();
// 调用方法
methodRerObject.printUpperCaseString(s);
});
// 简化后的写法,对象调用方法
// 前提是对象存在,方法存在
printString(new MethodRerObject()::printUpperCaseString);
}
}
通过类名称引用静态方法(demo2)
package com.wzlove.method.demo2;
/**@描述 计算绝对值的接口
*/
@FunctionalInterface
public interface Calcable {
int intAbs(int num);
}
package com.wzlove.method.demo2;
/**@描述
*/
public class Demo2 {
public static int methodAds(int num, Calcable calcable){
return calcable.intAbs(num);
}
public static void main(String[] args) {
// Lambda的写法
int num1 = methodAds(-100,num->Math.abs(num));
System.out.println(num1);
// 简化Lambda的写法
// 前提是类存在,静态方法存在
int result = methodAds(-100,Math::abs);
System.out.println(result);
}
}
类的构造器的使用(demo3)
package com.wzlove.method.demo3;
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 com.wzlove.method.demo3;
/
定义一个创建Person对象的函数式接口
/
@FunctionalInterface
public interface PersonBuilder {
//定义一个方法,根据传递的姓名,创建Person对象返回
Person builderPerson(String name);
}
package com.wzlove.method.demo3;
/**@描述
*/
public class Demo3 {
public static void buildPerson(String name, PersonBuilder pb){
Person person = pb.builderPerson(name);
System.out.println(person.getName());
}
public static void main(String[] args) {
buildPerson("杨紫",(name)->{
return new Person(name);
});
// 方法引用
// 有参构造
buildPerson("迪丽热巴",Person::new);
}
}
数组的构造器的引用(demo4)
package com.wzlove.method.demo4;
/
定义一个创建数组的函数式接口
/
@FunctionalInterface
public interface ArrayBuilder {
//定义一个创建int类型数组的方法,参数传递数组的长度,返回创建好的int类型数组
int[] builderArray(int length);
}
package com.wzlove.method.demo4;
/**@描述
*/
public class Demo4 {
public static int[] builderArr(int length, ArrayBuilder ab){
return ab.builderArray(length);
}
public static void main(String[] args) {
int[] arr1 = builderArr(5,length->new int[length]);
// 创建数组
int[] arr = builderArr(5,int[] :: new );
}
}
原文:https://www.cnblogs.com/wadmwz/p/9384668.html