程序示例:
import java.util.ArrayList;
public class StreamDemo1 {
public static void main(String[] args) {
/*
创建集合添加元素,完成以下需求:
1.把所有以“张”开头的元素存储到新集合中
2.把“张”开头的,长度为3的元素再存储到新集合中
3.遍历打印最终结果
*/
ArrayList<String> list1 = new ArrayList<>();
list1.add("张无忌");
list1.add("周芷若");
list1.add("赵敏");
list1.add("张强");
list1.add("张三丰");
list1.stream().filter(name -> name.startsWith("张")).filter(name -> name.length() == 3).forEach(name -> System.out.println(name));
/*
// 1.把所有以“张”开头的元素存储到新集合中
ArrayList<String> list2 = new ArrayList<>();
for (String name : list1) {
if(name.startsWith("张")){
list2.add(name);
}
}
// 2.把“张”开头的,长度为3的元素再存储到新集合中
ArrayList<String> list3 = new ArrayList<>();
for (String name : list2) {
if(name.length() == 3){
list3.add(name);
}
}
// 3.遍历打印最终结果
for (String name : list3) {
System.out.println(name);
}
*/
}
}
Stream 流的作用: 结合了 Lambda 表达式, 简化集合、数组的操作.
Stream 流的使用步骤:
-
先得到一条 Stream 流 (流水线), 并把数据放上去.
-
利用 Stream 流中的 API 进行各种操作.
Stream 流的使用步骤:
-
先得到一条 Stream 流 (流水线), 并把数据放上去
-
使用中间方法对流水线上的数据进行操作
-
使用终结方法对流水线上的数据进行操作
程序示例:
import java.util.ArrayList;
import java.util.Collections;
public class StreamDemo2 {
public static void main(String[] args) {
/*
单列集合 default Stream<E> stream() Collection中的默认方法
双列集合 无 无法直接使用stream流
数组 public static <T> Stream<T> stream(T[] array) Arrays工具类中的静态方法
一堆零散数据 public static<T> Stream<T> of(T... values) Stream接口中的静态方法
*/
//1.单列集合获取Stream流
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
/*//获取到一条流水线,并把集合中的数据放到流水线上
Stream<String> stream1 = list.stream();
//使用终结方法打印一下流水线上的所有数据
stream1.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
//s:依次表示流水线上的每一个数据
System.out.println(s);
}
});*/
list.stream().forEach(s -> System.out.println(s));
}
}
程序示例:
import java.util.HashMap;
public class StreamDemo3 {
public static void main(String[] args) {
// 双列集合 无 无法直接使用stream流
// 1.创建双列集合
HashMap<String, Integer> hm = new HashMap<>();
// 2.添加数据
hm.put("aaa", 111);
hm.put("bbb", 222);
hm.put("ccc", 333);
hm.put("ddd", 444);
// 3.第一种获取stream流
// hm.keySet().stream().forEach(s -> System.out.println(s));
// 4.第二种获取stream流
hm.entrySet().stream().forEach(s -> System.out.println(s));
}
}
程序示例:
import java.util.stream.Stream;
public class StreamDemo4 {
public static void main(String[] args) {
// 数组 public static <T> Stream<T> stream(T[] array) Arrays工具类中的静态方法
// 1.创建数组
int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
String[] arr2 = {"a", "b", "c"};
// 2.获取stream流
// Arrays.stream(arr1).forEach(s-> System.out.println(s));
// System.out.println("============================");
// Arrays.stream(arr2).forEach(s-> System.out.println(s));
// System.out.println("============================");
// 注意:
// Stream接口中静态方法of的细节
// 方法的形参是一个可变参数,可以传递一堆零散的数据,也可以传递数组
// 但是数组必须是引用数据类型的,如果传递基本数据类型,是会把整个数组当做一个元素,放到Stream当中。
Stream.of(arr1).forEach(s -> System.out.println(s));//[I@41629346
}
}
程序示例:
import java.util.stream.Stream;
public class StreamDemo5 {
public static void main(String[] args) {
// 一堆零散数据 public static<T> Stream<T> of(T... values) Stream接口中的静态方法
Stream.of(1, 2, 3, 4, 5).forEach(s -> System.out.println(s));
Stream.of("a", "b", "c", "d", "e").forEach(s -> System.out.println(s));
}
}
Stream 流的中间方法:
注意 1: 中间方法, 返回新的 Stream 流, 原来的 Stream流 只能使用一次, 建议使用链式编程.
注意 2: 修改 Stream 流中的数据, 不会影响原来集合或者数数组中的数据.
程序示例:
import java.util.ArrayList;
import java.util.Collections;
public class StreamDemo6 {
public static void main(String[] args) {
/*
filter 过滤
limit 获取前几个元素
skip 跳过前几个元素
注意1:中间方法,返回新的Stream流,原来的Stream流只能使用一次,建议使用链式编程
注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// filter 过滤 把张开头的留下,其余数据过滤不要
/*list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
//如果返回值为true,表示当前数据留下
//如果返回值为false,表示当前数据舍弃不要
return s.startsWith("张");
}
}).forEach(s -> System.out.println(s));
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s -> s.length() == 3)
.forEach(s -> System.out.println(s));
System.out.println("====================================");
System.out.println(list);*/
/* limit 获取前几个元素
skip 跳过前几个元素*/
//"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
// list.stream().limit(3).forEach(s -> System.out.println(s));
// list.stream().skip(4) .forEach(s -> System.out.println(s));
// 课堂练习:
//"张强", "张三丰", "张翠山"
// 第一种思路:
// 先获取前面6个元素:"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山",
// 然后跳过前面3个元素
// list.stream().limit(6).skip(3).forEach(s -> System.out.println(s));
// 第二种思路:
// 先跳过3个元素:"张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
// 然后再获取前面3个元素:"张强", "张三丰", "张翠山"
// list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));
}
}
程序示例:
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class StreamDemo8 {
public static void main(String[] args) {
/*
map 转换流中的数据类型
注意1:中间方法,返回新的Stream流,原来的Stream流只能使用一次,建议使用链式编程
注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");
// 需求:只获取里面的年龄并进行打印
// String->int
// 第一个类型:流中原本的数据类型
// 第二个类型:要转成之后的类型
// apply的形参s:依次表示流里面的每一个数据
// 返回值:表示转换之后的数据
// 当map方法执行完毕之后,流上的数据就变成了整数
// 所以在下面forEach当中,s依次表示流里面的每一个数据,这个数据现在就是整数了
list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");
String ageString = arr[1];
int age = Integer.parseInt(ageString);
return age;
}
}).forEach(s -> System.out.println(s));
System.out.println("------------------------");
list.stream()
.map(s -> Integer.parseInt(s.split("-")[1]))
.forEach(s -> System.out.println(s));
}
}
Stream 流的终结方法:
程序示例:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class StreamDemo9 {
public static void main(String[] args) {
/*
void forEach(Consumer action) 遍历
long count() 统计
toArray() 收集流中的数据,放到数组中
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// void forEach(Consumer action) 遍历
// Consumer的泛型:表示流中数据的类型
// accept方法的形参s:依次表示流里面的每一个数据
// 方法体:对每一个数据的处理操作(打印)
/*list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});*/
// list.stream().forEach(s -> System.out.println(s));
// long count() 统计
// long count = list.stream().count();
// System.out.println(count);
// toArray() 收集流中的数据,放到数组中
// Object[] arr1 = list.stream().toArray();
// System.out.println(Arrays.toString(arr1));
// IntFunction的泛型:具体类型的数组
// apply的形参:流中数据的个数,要跟数组的长度保持一致
// apply的返回值:具体类型的数组
// 方法体:就是创建数组
// toArray方法的参数的作用:负责创建一个指定类型的数组
// toArray方法的底层,会依次得到流里面的每一个数据,并把数据放到数组当中
// toArray方法的返回值:是一个装着流里面所有数据的数组
/* String[] arr = list.stream().toArray(new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];
}
});
System.out.println(Arrays.toString(arr));
*/
String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));
}
}
程序示例:
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class StreamDemo10 {
public static void main(String[] args) {
/*
collect(Collector collector) 收集流中的数据,放到集合中 (List Set Map)
注意点:
如果我们要收集到Map集合当中,键不能重复,否则会报错
*/
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
"张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
// 收集List集合当中
// 需求:
// 我要把所有的男性收集起来
List<String> newList1 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
// System.out.println(newList1);
// 收集Set集合当中
// 需求:
// 我要把所有的男性收集起来
Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
// System.out.println(newList2);
// 收集Map集合当中
// 谁作为键,谁作为值.
// 我要把所有的男性收集起来
// 键:姓名。 值:年龄
Map<String, Integer> map = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
/*
* toMap : 参数一表示键的生成规则
* 参数二表示值的生成规则
*
* 参数一:
* Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中键的数据类型
*
* 方法apply形参:依次表示流里面的每一个数据
* 方法体:生成键的代码
* 返回值:已经生成的键
*
*
* 参数二:
* Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中值的数据类型
*
* 方法apply形参:依次表示流里面的每一个数据
* 方法体:生成值的代码
* 返回值:已经生成的值
*
* */
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s) {
// 张无忌-男-15
return s.split("-")[0];
}
},
new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split("-")[2]);
}
}));
Map<String, Integer> map2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
s -> s.split("-")[0],
s -> Integer.parseInt(s.split("-")[2])));
System.out.println(map2);
}
}
标签:Stream,stream,list,System,println,out
From: https://www.cnblogs.com/Chengkai730/p/18436628