Java8---Stream-系统学习
1、Stream获取方式
package java8.stream;
import java.util.*;
import java.util.stream.Stream;
public class GetStreamTest {
public static void main(String[] args) {
//1、通过java.util.Collection的方法 default Stream<E> stream()
List<String> list= Arrays.asList("a","b","c");
Stream<String> stream = list.stream();
Set<String> set=new HashSet<>();
Stream<String> stream1 = set.stream();
Map<String,Object> map=new HashMap<>();
Stream<String> stream2 = map.keySet().stream();
Stream<Map.Entry<String, Object>> stream3 = map.entrySet().stream();
Stream<Object> stream4 = map.values().stream();
//2、通过java.util.stream.Stream的方法static<T> Stream<T> of(T... values)
Stream<String> stream5 = Stream.of();
Stream<String> stream6 = Stream.of("a", "b");;
String[] ss=new String[]{"a","b"};
Stream<String> stream7 = Stream.of(ss);
//【注意】基本数据类型不能使用Stream，会将整个数据作为流处理
int[] arr=new int[]{1,3};
Stream<int[]> stream8 = Stream.of(arr);
}
}
2、Stream常用方法及返回值
3、Stream使用注意事项
package java8.stream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class StreamUseNotice {
public static void main(String[] args) {
List<String> list= Arrays.asList("a","c");
//1、stream只能使用一次
Stream<String> stream = list.stream();
// stream.count();
// stream.count();
// 第二次使用报错：Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
//2、stream非终结方法返回的stream为新的stream
// Stream<String> stream1 = stream.filter(s -> s.equals("a"));
// System.out.println(stream);
// System.out.println(stream1);
//结果：
// java.util.stream.ReferencePipeline$Head@7ba4f24f
//java.util.stream.ReferencePipeline$2@3b9a45b3
//3、stream不调用终结方法，中间的不会执行
// stream.filter(s -> {
// System.out.println("未调用终结方法");
// return true;
// });
//结果：未输出任何信息
stream.filter(s -> {
System.out.println("调用终结方法");
return true;
}).count();
//结果:
//调用终结方法
//调用终结方法
}
}
4、Stream的常用方法
package java8.stream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamMethodTest {
public static void main(String[] args) {
// testForEach();
// testCount();
// testFilter();
// testLimit();
// testSkip();
// testMap();
// testSort();
// testDistinct();
// testMatch();
// testFind();
// testMax_Min();
// testReduce();
// testMap_Reduce();
// testMapToInt();
testConcat();
}
/**
* 将多个流 合并 为一个流
*/
private static void testConcat() {
Stream<String> stringStream = Stream.of("a");
Stream<Integer> integerStream = Stream.of(1, 2);
Stream<? extends Serializable> concatStream = Stream.concat(stringStream, integerStream);
concatStream.forEach(a->System.out.println(a));
//【注意】：合并后，之前的流不能再进行操作
}
/**
* 将Integer流转换为 int流，减少内存空间，装箱拆箱操作
*/
private static void testMapToInt() {
Stream<Integer> integerStream = Stream.of(1, 3, 4);
IntStream intStream = integerStream.mapToInt(a -> {
return a.intValue();
});
}
private static void testMap_Reduce() {
//得到所有人年龄总和
Optional<Integer> reduceSum = Stream.of(new Person("jack", 12), new Person("jack1", 13), new Person("jack3", 19)).map(a -> a.getAge()).reduce((x, y) -> x + y);
System.out.println(reduceSum.get());
//获取最大的年龄
Optional<Integer> reduceMax = Stream.of(new Person("jack", 12), new Person("jack1", 13), new Person("jack3", 19)).map(a -> a.getAge()).reduce((x, y) -> x > y ? x:y);
System.out.println(reduceMax.get());
//统计a出现的次数
Integer countA = Stream.of("a", "b", "a").map(s -> {
if (s.equals("a")) {
return 1;
} else {
return 0;
}
}).reduce((x, y) -> x + y).get();
System.out.println(countA);
}
/**
* 对流中的元素进行 处理，最终返回一个结果
*/
private static void testReduce() {
//T reduce(T identity, BinaryOperator<T> accumulator);
//identity:默认值、accumulator：流中元素处理逻辑
// Integer reduce = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> {
// return a + b;
// });
//简化后
Integer reduce = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> a + b);
System.out.println(reduce);
//获取最大值
Integer reduceMax = Stream.of(1, 3, 2, 4).reduce(0, (a, b) -> a > b ? a : b);
System.out.println(reduceMax);
}
/**
* 找 流中的最大值、最小值
*/
private static void testMax_Min() {
Optional<Integer> max = Stream.of(1, 3, 4).max((a, b) -> {
return a.compareTo(b);
});
System.out.println(max.get());
//简化后
System.out.println(Stream.of(1, 3, 4).max((a,b)->a.compareTo(b)).get());
}
/**
* 查找流中的第一个元素 findFirst,findAny都是找第一个元素
*/
private static void testFind() {
Stream<Integer> stream = Stream.of(1, 3, 4);
// Optional<Integer> first = stream.findFirst();
// System.out.println(first.get());
Optional<Integer> any = stream.findAny();
System.out.println(any.get());
}
/**
* 流中的元素是否满足某个条件
*/
private static void testMatch() {
Stream<Integer> stream = Stream.of(1, 3, 4);
boolean allMatch = stream.allMatch(a -> a > 1);//流中所有元素均满足某个条件
boolean anyMatch = stream.anyMatch(a -> a > 2);//流中任意一个元素满足某个条件
boolean noneMatch = stream.noneMatch(a -> a < 0);//流中所有元素不满足某个条件
}
/**
* 对流中的元素 去重
*/
private static void testDistinct() {
//基本类型
Stream<Integer> stream = Stream.of(1, 2, 3, 1, 2, 3);
stream.distinct().forEach(a->System.out.println(a));
//String类型
Stream<String> stream1 = Stream.of("a", "b", "c", "c", "c");
stream1.distinct().forEach(a->System.out.println(a));
//自定义类型
Stream<Person> stream2 = Stream.of(new Person("jack", 12), new Person("jack", 12), new Person("rose", 12), new Person("jack", 12));
stream2.distinct().forEach(a->System.out.println(a));
}
/**
* 对流中元素进行排序|自定义排序
*/
private static void testSort() {
Stream<Integer> stream = Stream.of(1, 3, 2, 5);
// stream.sorted().forEach(a->System.out.println(a));
// stream.sorted((a,b)->{
// return b.compareTo(a);
// }).forEach(a->System.out.println(a));
//优化后
stream.sorted((a,b)->b.compareTo(a)).forEach(a->System.out.println(a));
}
/**
* 将一种类型的流 转换成 另一种类型的流
*/
private static void testMap() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"1","2");
Stream<Integer> stream = list.stream().map((String s) -> {
return Integer.parseInt(s);
});
stream.forEach(s->System.out.println(s));
//简化后
list.stream().map(s->Integer.parseInt(s)).forEach(s->System.out.println(s));
}
/**
* 跳过流中的前几位元素
*/
private static void testSkip() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"a","b","c","d");
list.stream().skip(2).forEach(s->System.out.println(s));
}
/**
* 取流中的前几位元素
*/
private static void testLimit() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"a","b");
list.stream().limit(1).forEach(s->System.out.println(s));
}
/**
* 过滤流中的数据
*/
private static void testFilter() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"a","b");
list.stream().filter((String s)->{
return s.equals("a");
}).forEach((String s)->System.out.println(s));
//简化后
list.stream().filter(s->s.equals("a")).forEach(s->System.out.println(s));
}
/**
* 统计流中的数量
*/
private static void testCount() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"a","b");
//简化后
long count = list.stream().count();
System.out.println(count);
}
/**
* 遍历流中的元素
*/
private static void testForEach() {
List<String> list=new ArrayList<>();
Collections.addAll(list,"a","b");
//
list.stream().forEach((String s)->{
System.out.println(s);
});
//简化后
list.stream().forEach( s-> System.out.println(s));
}
}
浙公网安备 33010602011771号