湖北响应式网站设计制作,拼多多网站建设的目的,wordpress需要登录密码错误,许昌长葛网站建设制作设计Stream流 1. 概述2. 方法2.1 开始生成方法2.1.1 概述2.1.2 方法2.1.3 代码示例 2.2 中间操作方法2.2.1 概述2.2.2 方法2.2.3 代码示例 2.3 终结操作方法2.3.1 概述2.3.2 方法2.3.3 代码示例 2.4 收集操作方法2.4.1 概述2.4.2 方法2.4.3 代码示例 3. 代码示例14. 代码示例25. 代… Stream流 1. 概述2. 方法2.1 开始生成方法2.1.1 概述2.1.2 方法2.1.3 代码示例 2.2 中间操作方法2.2.1 概述2.2.2 方法2.2.3 代码示例 2.3 终结操作方法2.3.1 概述2.3.2 方法2.3.3 代码示例 2.4 收集操作方法2.4.1 概述2.4.2 方法2.4.3 代码示例 3. 代码示例14. 代码示例25. 代码示例36. 注意事项 1. 概述
Stream流是Java 8引入的一种新的数据处理方式它可以用来处理集合包括单列集合和双列集合和数组中的数据。它提供了一种优雅、声明式的方式来对数据进行操作和处理简化了对集合和数组的遍历、过滤、映射、排序等操作。
Stream流可以被认为是一种高级版本的迭代器。
与传统的集合迭代器相比Stream流具有以下特点 Stream流不会对原有的数据集合进行修改而是通过生成一个新的Stream流来进行操作。这种特性称为“惰性求值”也就是说在对Stream流的操作时并不会立即执行只有在终止操作如forEach、collect等被调用时才会真正执行计算过程。 Stream流支持并发操作可以使用并行流来进行高效的多线程处理。通过并行化操作可以极大地提高处理大数据集的效率。 Stream流的使用步骤 创建Stream流 可以通过集合类的stream()方法、数组的stream()方法或者使用Stream.of()方法来创建。 进行一系列中间操作 通过调用Stream流的方法来对数据进行过滤、映射、排序等操作这些操作会返回一个新的Stream流。 执行终止操作 使用终止操作来触发对Stream流的计算。常见的终止操作包括forEach遍历每个元素执行特定的操作、collect将元素收集到一个结果容器中、reduce归约操作将多个元素合并为一个结果等等。 代码示例 按照下面的要求完成集合的创建和遍历 “张三丰”,“张无忌”,“张翠山”,“王二麻子”,“张良”,“谢广坤” 创建一个集合存储多个字符串元素 把集合中所有以张开头的元素存储到一个新的集合 把张开头的集合中的长度为3的元素存储到一个新的集合 遍历上一步得到的集合 package text.text02;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;/*初爽Stream流
按照下面的要求完成集合的创建和遍历
张三丰,张无忌,张翠山,王二麻子,张良,谢广坤
- 创建一个集合存储多个字符串元素
- 把集合中所有以张开头的元素存储到一个新的集合
- 把张开头的集合中的长度为3的元素存储到一个新的集合
- 遍历上一步得到的集合*/
public class text62 {public static void main(String[] args) {//未使用Stream流System.out.println(未使用Stream流:);method1();//使用了Stream流System.out.println(使用了Stream流:);method2();}//使用了Stream流private static void method2() {//创建集合并添加字符串元素ArrayListString list new ArrayList();Collections.addAll(list, 张三丰, 张无忌, 张翠山, 王二麻子, 张良, 谢广坤);list.stream().filter(name - name.startsWith(张)).filter(name - name.length() 3).forEach(new ConsumerString() {Overridepublic void accept(String name) {System.out.print(name );}});}//未使用Stream流public static void method1() {//创建集合并添加字符串元素ArrayListString list new ArrayList();Collections.addAll(list, 张三丰, 张无忌, 张翠山, 王二麻子, 张良, 谢广坤);//遍历集合获取以“张”开头的元素并存在新的集合中ArrayListString list1 new ArrayList();for (String name : list) {if (name.startsWith(张)) {list1.add(name);}}System.out.println(所有以\张\开头的元素存储到一个新的集合: list1); //[张三丰, 张无忌, 张翠山, 张良]//把张开头的集合中的长度为3的元素存储到一个新的集合ArrayListString list2 new ArrayList();for (String name : list1) {if (name.length() 3) {list2.add(name);}}System.out.println(把\张\开头的集合中的长度为3的元素存储到一个新的集合: list2); //[张三丰, 张无忌, 张翠山]}
}输出结果 未使用Stream流 使用了Stream流
2. 方法
2.1 开始生成方法
2.1.1 概述
Stream流开始生成方法是指用于创建和获取Stream流的一些方法。在Java中Stream是一种处理数据集合的抽象概念它提供了丰富的数据操作和处理功能。 为了使用Stream我们需要首先生成或获取到一个Stream流对象。 生成Stream流的方式 Collection体系集合 使用默认方法stream()生成流 default Stream stream() Map体系集合 把Map转成Set集合间接的生成流 数组 通过Arrays中的静态方法stream生成流 同种数据类型的多个数据 通过Stream接口的静态方法of(T… values)生成流
2.1.2 方法
获取方式方法名说明单列集合default Streamstream()Collection中的默认方法双列集合无无法直接使用stream流数组public static Stream stream(T[] array)Arrays工具类中的静态方法-堆零散数据public staticStream of(T… values)Stream接口中的静态方法
细节 单列集合default StreamE stream()此方法是Collection接口中的默认方法用于将单列集合如List、Set转换为Stream流。 例如 ListString list Arrays.asList(A, B, C);
StreamString stream list.stream();双列集合目前没有直接使用stream()方法将双列集合如Map转换为Stream流的方式。但是可以通过entrySet().stream()或keySet().stream()等方式间接获得Stream流以对双列集合进行操作。 数组public static T StreamT stream(T[] array)此方法是Arrays工具类中的静态方法用于将数组转换为Stream流。 例如 String[] array {A, B, C};
StreamString stream Arrays.stream(array);散零数据public static T StreamT of(T... values)此方法是Stream接口中的静态方法用于将一系列散零的数据转换为Stream流。 例如 StreamString stream Stream.of(A, B, C);2.1.3 代码示例 代码示例1单列集合 package text.text02;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;/*生成方法单列集合 | default StreamEstream()| 获取方式 | 方法名 | 说明 |
| ----------- | --------------------------------------------- | ------------------------ |
| 单列集合 | default StreamEstream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static T StreamT stream(T[] array) | Arrays工具类中的静态方法 |
| -堆零散数据 | public staticTStreamT of(T... values) | Stream接口中的静态方法 |*/
public class text63 {public static void main(String[] args) {//完整模式System.out.println(完整模式);method1(); //aaa bbb ccc ddd eee fff ggg hhh iii jjj kkkSystem.out.println();//简写模式System.out.println(简写模式);method2(); //aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk}//简写模式private static void method2() {//创建单列集合ArrayListString list new ArrayList();//添加数据Collections.addAll(list, aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii, jjj, kkk);//创建Stream流并输出list.stream().forEach(s - System.out.print(s ));}public static void method1() {//创建单列集合ArrayListString list new ArrayList();//添加数据Collections.addAll(list, aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii, jjj, kkk);//创建Stream流StreamString stream list.stream();//输出数据stream.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});}
} 输出结果:单列集合 代码示例2双列集合 package text.text02;import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;/*生成方法
双列集合 | 无
双列集合无stream流必须先利用keySet()或者entrySet()方法转化成单列集合才可以使用| 获取方式 | 方法名 | 说明 |
| ----------- | --------------------------------------------- | ------------------------ |
| 单列集合 | default StreamEstream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static T StreamT stream(T[] array) | Arrays工具类中的静态方法 |
| -堆零散数据 | public staticTStreamT of(T... values) | Stream接口中的静态方法 |
*/
public class text64 {public static void main(String[] args) {//创建双列集合HashMapString, Integer hm new HashMap();//添加数据hm.put(手机, 1003);hm.put(电脑, 1005);hm.put(平板, 1001);hm.put(汽车, 1002);hm.put(飞机, 1004);//利用keySet()转化成单列集合System.out.println(利用keySet()转化成单列集合);method1(hm);//利用entrySet()方法转化成单列集合System.out.println(利用entrySet()方法转化成单列集合);method2(hm);}//利用entrySet()方法转化成单列集合private static void method2(HashMapString, Integer hm) {//将双列集合转成单列集合entrySet()方法SetMap.EntryString, Integer entries hm.entrySet();entries.stream().forEach(new ConsumerMap.EntryString, Integer() {Overridepublic void accept(Map.EntryString, Integer stringIntegerEntry) {System.out.println(stringIntegerEntry);}});}//利用keySet()转化成单列集合private static void method1(HashMapString, Integer hm) {//将双列集合转成单列集合keySet()方法SetString set hm.keySet();set.stream().forEach(new ConsumerString() {Overridepublic void accept(String key) {Integer value hm.get(key);System.out.println(key value);}});}
} 输出结果双列集合 利用keySet()转化成单列集合 利用entrySet()方法转化成单列集合 代码示例3数组 package text.text02;import java.util.Arrays;
import java.util.stream.Stream;/*生成方法数组 | public static T StreamT stream(T[] array)
注意Stream接口中的静态方法of的细节方法的形参是一个可变参数可以传递一堆零散的数据也可以传递数组但是数组只能是引用数据类型的如果传递基本数据类型的是会把整个数组当成一个元素放到Stream流中| 获取方式 | 方法名 | 说明 |
| ----------- | --------------------------------------------- | ------------------------ |
| 单列集合 | default StreamEstream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static T StreamT stream(T[] array) | Arrays工具类中的静态方法 |
| -堆零散数据 | public staticTStreamT of(T... values) | Stream接口中的静态方法 |*/
public class text65 {public static void main(String[] args) {//创建数组int[] arr {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//使用Arrays里的stream方法Arrays.stream(arr).forEach(s - System.out.println(s));//直接使用Stream里的of方法//注意Stream接口中的静态方法of的细节//方法的形参是一个可变参数可以传递一堆零散的数据也可以传递数组//但是数组只能是引用数据类型的如果传递基本数据类型的是会把整个数组当成一个元素放到Stream流中Stream.of(arr).forEach(s - System.out.println(s)); //[I3d075dc0}
} 输出结果数组 使用静态Stream方法 直接使用Stream里的of方法 代码示例4一堆零散数据 package text.text02;import java.util.function.Consumer;
import java.util.stream.Stream;/*生成方法一堆零散数据 | public staticTStreamT of(T... values)
必须是同一种数据类型| 获取方式 | 方法名 | 说明 |
| ----------- | --------------------------------------------- | ------------------------ |
| 单列集合 | default StreamEstream() | Collection中的默认方法 |
| 双列集合 | 无 | 无法直接使用stream流 |
| 数组 | public static T StreamT stream(T[] array) | Arrays工具类中的静态方法 |
| -堆零散数据 | public staticTStreamT of(T... values) | Stream接口中的静态方法 |
*/
public class text66 {public static void main(String[] args) {//创建stream流并输出Stream.of(aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii, jjj, kkk).forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.println(s);}});}
}输出结果一堆零散数据
2.2 中间操作方法
2.2.1 概述
当处理 Java 8 中的 Stream 流时中间操作方法用于对流中的元素进行处理和转换。
中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作
2.2.2 方法
方法名说明Stream filter(Predicate? super T predicate)用于对流中的数据进行过滤。只保留满足给定条件的元素。Stream limit(long maxSize)获取流中的前N个元素如果流中的元素数量小于N则返回流中的所有元素。Stream skip(long n)跳过流中的前N个元素返回剩余的元素。如果流中的元素数量小于N则返回空流。Stream distinct()对流中的元素进行去重操作去重依赖元素的hashCode和equals方法。如果是自定义对象需要重写hashCode和equals方法。static Stream concat(Stream a, Stream b)将两个流a和b合并为一个流按照a流的顺序先输出然后按照b流的顺序输出。Stream map(FunctionT,R mapper)对流中的每个元素进行映射操作将其转换为另一种类型的元素通过给定的函数进行转换。
注意1: 中间方法返回新的Stream流原来的Stream流只能使用一次建议使用链式编程注意2: 修改Stream流中的数据不会影响原来集合或者数组中的数据
细节
filter方法获取流中的每一个数据.而test方法中的s就依次表示流中的每一个数据.我们只要在test方法中对s进行判断就可以了. 如果判断的结果为true,则当前的数据留下 如果判断的结果为false,则当前数据就不要.
2.2.3 代码示例
代码示例package text.text02;import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;/*操作方法
| 方法名 | 说明
| ----------------------------------------------- | -----------------------------------------------------
| StreamT filter(Predicate? super T predicate) | 用于对流中的数据进行过滤
| StreamT limit(long maxSize) | 获取前几个元素
| StreamT skip(long n) | 跳过前几个元素
| StreamT distinct() | 元素去重依赖(hashcode和equals方法)如果是自定义对象必须重写hashcode和equals方法
| staticT StreamTconcat(Stream a, Stream b) | 合并a和b两个流为一个流
| StreamR map(FunctionT,R mapper) | 转换流中的数据类型- 注意1:中间方法返回新的Stream流原来的Stream流只能使用一次建议使用链式编程
- 注意2:修改Stream流中的数据不会影响原来集合或者数组中的数据*/
public class text67 {public static void main(String[] args) {//创建集合并添加数据ArrayListString list new ArrayList();Collections.addAll(list, 吕布, 吕布, 吕布, 吕布, 吕布, 貂蝉, 小乔, 孙策, 大乔, 露娜, 刘备, 孙悟空, 凯, 亚瑟, 刘邦, 项羽, 张飞, 武则天, 钟无艳, 孙膑, 赵云, 妲己, 公孙离);//1.StreamT filter(Predicate? super T predicate): 用于对流中的数据进行过滤System.out.println(1.StreamT filter(Predicate? super T predicate): 用于对流中的数据进行过滤);System.out.println(以“张”开头的姓名有);//获取Stream流对象list.stream()//调用Stream流中的filter()过滤方法.filter(new PredicateString() {Override//filter方法获取流中的 每一个数据.//而test方法中的s就依次表示流中的每一个数据.//我们只要在test方法中对s进行判断就可以了.//如果判断的结果为true,则当前的数据留下//如果判断的结果为false,则当前数据就不要.public boolean test(String s) {return s.startsWith(孙);}})//遍历输出Stream流.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//2.StreamT limit(long maxSize) : 获取前几个元素System.out.println(2.StreamT limit(long maxSize) : 获取前几个元素);System.out.println(获取前5个元素是);//获取Stream流对象list.stream()//调用Stream流中的limit()方法.limit(5)//遍历Stream流.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//3.StreamT skip(long n):跳过前几个元素System.out.println(3.StreamT skip(long n):跳过前几个元素);System.out.println(跳过前5个元素剩下的元素是);//获取Stream流对象list.stream()//调用Stream中的skip()方法.skip(5)//遍历Stream流.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//4.StreamT distinct() :元素去重依赖(hashcode和equals方法)// 如果是自定义对象必须重写hashcode和equals方法System.out.println(4.StreamT distinct() :元素去重依赖(hashcode和equals方法));System.out.println(元素去重后的元素是);//获取Stream流对象list.stream()//调用Stream流中的distinct()方法.distinct()//遍历Stream流.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//5.staticT StreamT concat(Stream a, Stream b) : 合并a和b两个流为一个流//注意如果合并的两个流是同种数据类型则合并后的流也是该数据类型// 如果合并的两个流不是同种数据类型则合并后的流是父类数据类型且不能使用子类的方法System.out.println(5.staticT StreamTconcat(Stream a, Stream b) : 合并a和b两个流为一个流);System.out.println(将list流和list1流合并后的元素为);//创建list1集合ArrayListString list1 new ArrayList();Collections.addAll(list1, 张三丰, 张无忌, 张翠山, 王二麻子, 张良, 谢广坤);//调用Stream流中的concat方法静态方法直接通过类名调用Stream.concat(list1.stream(), list.stream())//遍历Stream流.forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//6.StreamR map(FunctionT,R mapper): 转换流中的数据类型System.out.println(6.StreamR map(FunctionT,R mapper): 转换流中的数据类型 );System.out.println(流中的年龄为);ArrayListString list2 new ArrayList();Collections.addAll(list2, 张三丰-11, 张无忌-12, 张翠山-12, 王二麻子-23, 张良-14, 谢广坤-15);//获取Stream流对象list2.stream()//调用Stream流中的map方法第一个类型流中原本的类型第二个类型要转成的类型.map(new FunctionString, Integer() {Override//apply方法的参数s依次表示流中的每一个数据//返回值表示要转换之后的数据public Integer apply(String s) {//根据“-”分割字符串String[] arr s.split(-);//获取字符串分割后的年龄String ageString arr[1];//将字符串类型转换成Integer类型int age Integer.parseInt(ageString);return age;}})//遍历Stream流.forEach(new ConsumerInteger() {Overridepublic void accept(Integer integer) {System.out.print(integer );}});System.out.println();System.out.println(简写方式:);//简写方式list2.stream().map(s - Integer.parseInt(s.split(-)[1])).forEach(s - System.out.print(s ));}
} 输出结果 1.Stream filter(Predicate? super T predicate): 用于对流中的数据进行过滤 2.Stream limit(long maxSize) : 获取前几个元素 3.Stream skip(long n):跳过前几个元素 4.Stream distinct() :元素去重依赖(hashcode和equals方法) 5.static Streamconcat(Stream a, Stream b) : 合并a和b两个流为一个流 6.Stream map(FunctionT,R mapper): 转换流中的数据类型
2.3 终结操作方法
2.3.1 概述
在处理 Java 8 中的 Stream 流时可以通过终端操作方法来触发对流的处理并生成最终的结果。
终结方法终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作
2.3.2 方法
方法名说明void forEach(Consumer action)对此流的每个元素执行遍历操作long count()统计toArray()收集流中的数据放到数组中collect(Collector collector)收集流中的数据放到集合中
细节
toArray方法的参数的作用负责创建一个指定类型的数组toArray方法的返回值是一个装着流里面所有数据的数组
2.3.3 代码示例
代码示例package text.text02;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;/*终结方法终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作| 方法名 | 说明
| ----------------------------- | ------------------------
| void forEach(Consumer action) | 对此流的每个元素执行遍历操作
| long count() | 统计
| toArray() | 收集流中的数据放到数组中
| collect(Collector collector) | 收集流中的数据放到集合中
细节· toArray方法的参数的作用负责创建一个指定类型的数组· toArray方法的返回值是一个装着流里面所有数据的数组*/
public class text68 {public static void main(String[] args) {//创建集合并添加数据ArrayListString list new ArrayList();Collections.addAll(list, 吕布, 吕布, 吕布, 吕布, 吕布, 貂蝉, 小乔, 孙策, 大乔, 露娜, 刘备);System.out.println();//1.void forEach(Consumer action): 对此流的每个元素执行遍历操作System.out.println(1.void forEach(Consumer action): 对此流的每个元素执行遍历操作);//完整写法System.out.println(完整写法:);list.stream().forEach(new ConsumerString() {Overridepublic void accept(String s) {System.out.print(s );}});System.out.println();//简单写法System.out.println(简单写法:);list.stream().forEach(s - System.out.print(s ));System.out.println();//2.long count() : 统计System.out.println(2.long count() : 统计);//完整写法System.out.print(完整写法:);long count list.stream().count();System.out.println(count);//简单写法System.out.print(简单写法:);System.out.println(list.stream().count());//3.toArray() : 收集流中的数据放到数组中System.out.println(3.toArray() : 收集流中的数据放到数组中);//参数为空System.out.print(参数为空:);Object[] arr1 list.stream().toArray();System.out.println(Arrays.toString(arr1));//参数不为空System.out.println(参数不为空:);//完整形式System.out.println(完整形式:);String[] arr2 list.stream()//IntFunction的泛型具体类型的数组//toArray方法的参数的作用负责创建一个指定类型的数组//toArray方法的返回值是一个装着流里面所有数据的数组.toArray(new IntFunctionString[]() {Override//apply的形参流中数组的个数要跟数组的长度保持一致//apply的返回值集体类型的数组public String[] apply(int value) {return new String[value];}});System.out.println(Arrays.toString(arr2));//简单形式System.out.println(简单形式:);System.out.println(Arrays.toString(list.stream().toArray(value - new String[value])));}
} 输出结果 1.void forEach(Consumer action): 对此流的每个元素执行遍历操作 2.long count() : 统计 3.toArray() : 收集流中的数据放到数组中
2.4 收集操作方法
2.4.1 概述
在 Java 8 中Stream 提供了强大的收集操作方法可以将流中的元素收集到不同类型的集合中或者生成其他形式的结果。
2.4.2 方法
collect(Collector collector) | 收集流中的数据放到集合中 (List、Set、Map) toMap 参数一表示键的生成规则参数二表示值的生成规则 参数一 Function 泛型一表示流中每一个数据的 泛型二表示Map集合中键的 apply方法 形参依次表示流里面的每一个数方法体生成键的代码返回值已经生成的键 参数二 Function 泛型一表示流中每一个数据的 泛型二表示Map集合中值的 apply方法 形参依次表示流里面的每一个数 方法体生成值的代码 返回值已经生成的值 注意如果要收集到Map集合当中键不能重复否则会报错 工具类Collectors提供了具体的收集方式
方法名说明public static Collector toList()把元素收集到List集合中public static Collector toSet()把元素收集到Set集合中public static Collector toMap(Function keyMapper, Function valueMapper)把元素收集到Map集合中
2.4.3 代码示例
代码示例package text.text02;import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;/*collect(Collector collector) | 收集流中的数据放到集合中 (List、Set、Map)toMap参数一表示键的生成规则参数二表示值的生成规则
参数一Function泛型一表示流中每一个数据的泛型二表示Map集合中键的apply方法形参依次表示流里面的每一个数方法体生成键的代码返回值已经生成的键
参数二Function泛型一表示流中每一个数据的泛型二表示Map集合中值的apply方法形参依次表示流里面的每一个数方法体生成值的代码返回值已经生成的值注意如果要收集到Map集合当中键不能重复否则会报错工具类Collectors提供了具体的收集方式| 方法名 | 说明 |
| ------------------------------------------------------------ | ---------------------- |
| public static T Collector toList() | 把元素收集到List集合中 |
| public static T Collector toSet() | 把元素收集到Set集合中 |
| public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |*/
public class text69 {public static void main(String[] args) {//创建集合对象并添加元素ArrayListString list new ArrayList();Collections.addAll(list, 吕布-男-14, 吕布-男-14, 吕布-男-14, 吕布-男-14, 吕布-男-14, 貂蝉-女-13, 小乔-女-16, 孙策-男-17, 大乔-女-17, 露娜-女-15, 刘备-男-18);//1.把元素收集到List集合中//需求将男生收集到List集合System.out.println(1.把元素收集到List集合中);//完整模式System.out.println(完整模式:);//创建Stream对象ListString collect1 list.stream()//调用Stream流里的filter()过滤方法.filter(new PredicateString() {Overridepublic boolean test(String s) {//分割字符串String[] arr1 s.split(-);//获取分割之后的索引为1的字符串String s1 arr1[1];return 男.equals(s1);}})//调用Stream流中的collect方法.collect(Collectors.toList());System.out.println(collect1);//简写模式System.out.println(简写模式:);System.out.println(list.stream().filter(s - 男.equals(s.split(-)[1])).collect(Collectors.toList()));//2.把元素收集到Set集合中//需求将男生收集到Set集合System.out.println(2.把元素收集到Set集合中);//完整模式System.out.println(完整模式:);//创建Stream对象SetString collect2 list.stream()//调用Stream流里的filter()过滤方法.filter(new PredicateString() {Overridepublic boolean test(String s) {//分割字符串String[] arr1 s.split(-);//获取分割之后的索引为1的字符串String s1 arr1[1];return 男.equals(s1);}})//调用Stream流中的collect方法.collect(Collectors.toSet());System.out.println(collect2);//简写模式System.out.println(简写模式:);System.out.println(list.stream().filter(s - 男.equals(s.split(-)[1])).collect(Collectors.toSet()));//3.把元素收集到Map集合中//注意如果要收集到Map集合当中键不能重复否则会报错//创建不重复的集合对象并添加元素ArrayListString list1 new ArrayList();Collections.addAll(list1, 吕布-男-14, 貂蝉-女-13, 小乔-女-16, 孙策-男-17, 大乔-女-17, 露娜-女-15, 刘备-男-18);System.out.println(3.把元素收集到Map集合中);//完整模式System.out.println(完整模式:);MapString, Integer collect list1.stream()//调用Stream里的filter过滤方法.filter(new PredicateString() {Overridepublic boolean test(String s) {//分割字符串String[] split s.split(-);//获取分割字符串之后的索引为1的字符串String s1 split[1];return 男.equals(s1);}})/*toMap参数一表示键的生成规则参数二表示值的生成规则参数一Function泛型一表示流中每一个数据的类型泛型二表示Map集合中键的数据类型apply方法形参依次表示流里面的每一个数据方法体生成键的代码返回值已经生成的键参数二Function泛型一表示流中每一个数据的类型泛型二表示Map集合中值的数据类型apply方法形参依次表示流里面的每一个数据方法体生成值的代码返回值已经生成的值*/.collect(Collectors.toMap(new FunctionString, String() {Override//生成键public String apply(String key) {//获取分割字符串之后的索引为0的字符串String s key.split(-)[0];return s;}}, new FunctionString, Integer() {Override//生成值public Integer apply(String value) {//获取分割字符串之后的索引为2的字符串String s value.split(-)[2];//将字符串转换成Integer类型int i Integer.parseInt(s);return i;}}));System.out.println(collect);//简写模式System.out.println(简写模式:);System.out.println(list1.stream().filter(s - 男.equals(s.split(-)[1])).collect(Collectors.toMap(key - key.split(-)[0], value - Integer.parseInt(value.split(-)[2]))));}
} 输出结果 1.把元素收集到List集合中 2.把元素收集到Set集合中 3.把元素收集到Map集合中
3. 代码示例1
代码示例 数据过滤 定义一个集合并添加一些整数1,2,3,4,5,6,7,8,9,10过滤奇数只留下偶数并将结果保存起来。package text.text02;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;/*
数据过滤定义一个集合并添加一些整数1,2,3,4,5,6,7,8,9,10过滤奇数只留下偶数并将结果保存起来。*/
public class text70 {public static void main(String[] args) {//定义集合并添加数据ArrayListInteger list new ArrayList();Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);//完整模式System.out.println(完整模式:);ListInteger collect list.stream()//过滤.filter(new PredicateInteger() {Overridepublic boolean test(Integer integer) {//如果判断的结果为true,则当前的数据留下//如果判断的结果为false,则当前数据就不要.return integer % 2 0;}})//保存数据.collect(Collectors.toList());//输出保存的集合System.out.println(collect); //[2, 4, 6, 8, 10]//省略模式System.out.println(省略模式:);System.out.println(list.stream().filter(n - n % 2 0).collect(Collectors.toList()));}
} 输出结果
4. 代码示例2 代码示例 数据操作创建一个ArrayList集合并添加以下字符串字符串中前面的是姓名后面是年龄保留年龄大于等于24岁的人并将结果收集到Map集合中姓名为键年龄为值 zhangsan,23lisi,24wangwu,25package text.text02;import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;/*
数据操作
创建一个ArrayList集合并添加以下字符串字符串中前面的是姓名后面是年龄
zhangsan,23
lisi,24
wangwu,25
保留年龄大于等于24岁的人并将结果收集到Map集合中姓名为键年龄为值*/
public class text71 {public static void main(String[] args) {//创建集合并添加字符串ArrayListString list new ArrayList();Collections.addAll(list, zhangsan,23, lisi,24, wangwu,25);//完整模式System.out.println(完整模式:);MapString, Integer map list.stream()//过滤.filter(new PredicateString() {Overridepublic boolean test(String s) {String[] split s.split(,);String s1 split[1];int age Integer.parseInt(s1);return age 24;}})//收集数据(保存).collect(Collectors.toMap(//键new FunctionString, String() {Overridepublic String apply(String s) {return s.split(,)[0];}}//值, new FunctionString, Integer() {Overridepublic Integer apply(String s) {return Integer.parseInt(s.split(,)[1]);}}));System.out.println(map); //{lisi24, wangwu25}//省略模式System.out.println(省略模式:);System.out.println(list.stream().filter(s - Integer.parseInt(s.split(,)[1]) 24).collect(Collectors.toMap(key - key.split(,)[0], value - Integer.parseInt(value.split(,)[1]))));}
} 输出结果
5. 代码示例3 代码示例 现在有两个ArrayList集合第一个集合中存储6名男演员的名字和年龄。第二个集合中存储6名女演员的名字和年龄姓名和年龄之间用逗号隔开。比如张三23 要求完成如下操作 男演员只要名字为3个字的前两人 女演员只要姓杨的并且不要第一个 把过滤后的男演员姓名和女演员姓名合并到一起 将上一步的演员信息封装成Actor对象 将所有的演员对象都保存到List集合中 备注演员类Actor属性nameage package text.text02;import java.util.ArrayList;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;/*
现在有两个ArrayList集合第一个集合中存储6名男演员的名字和年龄。第二个集合中存储6名女演员的名字和年龄姓名和年龄之间用逗号隔开。比如张三23
要求完成如下操作
1.男演员只要名字为3个字的前两人
2.女演员只要姓杨的并且不要第一个
3.把过滤后的男演员姓名和女演员姓名合并到一起
4.将上一步的演员信息封装成Actor对象
5.将所有的演员对象都保存到List集合中
备注演员类Actor属性nameage*/
public class text72 {public static void main(String[] args) {//创建集合ArrayListString manList new ArrayListString();manList.add(周润发,23);manList.add(成龙,24);manList.add(刘德华,46);manList.add(吴京,14);manList.add(周星驰,25);manList.add(李连杰,54);ArrayListString womanList new ArrayListString();womanList.add(林心如,24);womanList.add(张曼玉,35);womanList.add(杨幂,15);womanList.add(杨柳岩,23);womanList.add(林志玲,45);womanList.add(杨祖贤,23);//1.男演员只要名字为3个字的前两人StreamString manStream manList.stream().filter(s - s.split(,)[0].length() 3).limit(2);//2.女演员只要姓杨的并且不要第一个StreamString womenStream womanList.stream().filter(s - s.split(,)[0].startsWith(杨)).skip(1);//3.把过滤后的男演员姓名和女演员姓名合并到一起StreamString stream Stream.concat(manStream, womenStream);//4.将上一步的演员信息封装成Actor对象stream.map(new FunctionString, Actor() {Overridepublic Actor apply(String s) {//获取姓名String name s.split(,)[0];//获取年龄int age Integer.parseInt(s.split(,)[1]);//返回对象return new Actor(name, age);}})//5.将所有的演员对象都保存到List集合中.collect(Collectors.toList())//遍历保存的List集合集合.forEach(new ConsumerActor() {Overridepublic void accept(Actor actor) {System.out.println(actor.getName() , actor.getAge());}});}
}class Actor {private String name;private int age;public Actor() {}public Actor(String name, int age) {this.name name;this.age age;}/*** 获取** return name*/public String getName() {return name;}/*** 设置** param name*/public void setName(String name) {this.name name;}/*** 获取** return age*/public int getAge() {return age;}/*** 设置** param age*/public void setAge(int age) {this.age age;}public String toString() {return Actor{name name , age age };}
} 输出结果
6. 注意事项 流只能遍历一次一旦对流进行了终端操作比如使用了终端操作方法或者转换为了一个集合流就已经被消耗完毕不能再进行其他操作。如果需要对流进行多次操作可以通过创建新的流来实现。 及早终止操作流中定义的操作分为两类中间操作和终端操作。中间操作像过滤、映射等只返回一个新的流而终端操作才会触发流的处理。如果不进行终端操作中间操作不会被执行。 流的惰性求值在执行终端操作之前中间操作不会立即执行。只有在需要结果时才会触发中间操作执行。这种延迟求值的特性可以提高性能。 避免使用无限流Stream 提供了生成无限流的方法如 iterate 和 generate。使用时要特别小心确保有适当的终止条件否则会导致无限循环。
