Java8新特性-Stream，java常⽤算法⾯试题Stream stream = Stream.iterate(0, x -> x + 2).limit(3);
stream.forEach(System.out::println);
}
输出结果
2
4
创建⽆限流
@Test
public void testUnlimitStream2() {
Stream stream = ate(() -> “number” + new Random().nextInt()).limit(3);
stream.forEach(System.out::println);
}
输出结果
number1042047526
number-155761434
number-1605164634
创建空流
@Test
public void testEmptyStream() {
java streamStream stream = pty();
stream.forEach(System.out::println);
}
Stream操作分类
中间操作⼜可以分为⽆状态（Stateless）与有状态（Stateful）操作，
⽆状态是指元素的处理不受之前元素的影响，
有状态是指该操作只有拿到所有元素之后才能继续下去。
终结操作⼜可以分为短路（Short-circuiting）与⾮短路（Unshort-circuiting）操作，
短路是指遇到某些符合条件的元素就可以得到最终结果，
⾮短路是指必须处理完所有元素才能得到最终结果。
我们通常还会将中间操作称为懒操作，也正是由这种懒操作结合终结操作、数据源构成的处理管道（Pipeline），实现了 Stream 的⾼效。
中间操作
⽆状态
filter：过滤流，过滤流中的元素
map：转换流，将⼀种类型的流转换为另外⼀种类型的流
flapMap：拆解流，将流中每⼀个元素拆解成⼀个流
filter
filter接收⼀个Predicate函数接⼝参数，boolean test(T t)；即接收⼀个参数，返回boolean类型。
@Test
public void testFilter() {
Integer[] arr = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Arrays.stream(arr).filter(x -> x > 3 && x < 8).forEach(System.out::println);
}
输出结果
4
5
6
7
map
map接收⼀个Function<T, R>函数接⼝，R apply(T t)；即接收⼀个参数，并且有返回值。
@Test
public void testMap() {
String[] arr = new String[]{“yes”, “YES”, “no”, “NO”};
Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);
}
输出结果
yes
yes
no
no
flapMap
flatMap接收⼀个Function<T, R>函数接⼝： Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)；即⼊参为集合类型，返回Stream类型。
@Test
public void testFlatMap() {
String[] arr1 = {“a”, “b”};
String[] arr2 = {“e”, “f”};
String[] arr3 = {“h”, “j”};
// Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);
}
输出结果
a
b
e
f
h
j
有状态
distinct：元素去重
sorted：元素排序
limit：获取前⾯的指定数量的元素
skip：跳过前⾯指定数量的元素，获取后⾯的元素
concat：把两个stream合并成⼀个stream
distinct
@Test
public void testDistinct() {
List list = new ArrayList() {
{
add(“user1”);
add(“user2”);
add(“user2”);
add(“user2”);
}
};
list.stream().distinct().forEach(System.out::println); }
输出结果
user1
user2
sorted
sorted
@Test
public void testSorted1() {
String[] arr1 = {“abc”, “a”, “bc”, “abcd”};
// 按照字符长度排序
System.out.println(“lambda表达式”);
Arrays.stream(arr1).sorted((x, y) -> {
if (x.length() > y.length())
return 1;
else if (x.length() < y.length())
return -1;
else
return 0;
}).forEach(System.out::println);
// Comparatorparing是⼀个键提取的功能
System.out.println(“⽅法引⽤”);
Arrays.stream(arr1).sorted(Comparatorparing(String::length)).forEach(System.out::println);
}
输出结果
lambda表达式
a
bc
abc
abcd
⽅法引⽤
a
bc
abc
abcd
reversed
/**
倒序
reversed(),java8泛型推导的问题，所以如果comparing⾥⾯是⾮⽅法引⽤的lambda表达式就没办法直接使⽤reversed() verseOrder()：也是⽤于翻转顺序，⽤于⽐较对象（Stream⾥⾯的类型必须是可⽐较的）
Comparator.naturalOrder()：返回⼀个⾃然排序⽐较器，⽤于⽐较对象（Stream⾥⾯的类型必须是可⽐较的）
*/
@Test

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。