Java8 Stream简介
Stream是Java 8新增的重要特性, 它提供函数式编程支持并允许以管道方式操作集合. 流操作会遍历数据源, 使用管道式操作处理数据后生成结果集合, 这个过程通常不会对数据源造成影响.
函数对象
使用Stream进行函数式编程时经常需要将操作作为参数传入流方法中, 函数对象即将方法或lambda表达式作为对象.
import java.util.stream.Collectors;List list = Arrays.asList(-1,0,1,2,3).stream()
.filter(x -> x>0)
.collect(Collectors.toList());
上述示例中filter
的参数x -> x>0
即为一个lambda表达式.
lambda表达式语法通常为(args)->{body}
, 返回值的类型自动推定:
(int a, int b) -> { if (a>b) {
return a+b;
}
else {
return a * b;
}
}
参数的类型也可以自动推定:
(a, b) -> { return a+b;
}
在只有一条语句的情况下{}
可省略, 返回值类型与语句主体表达式一致.
(a, b) -> a+b
允许使用空参数:
() -> {System.out.println("Hello World!")}
::
运算符用于将方法表示为函数对象:
List<Item> items = new ArrayList<>();items.add(new Item("a"));
items.add(new Item("b"));
List<String> list = items.stream()
.map(Item::getMsg)
.collect(Collectors.toList());
for(String str : list) {
System.out.println(str);
}
流的创建
可以使用集合类的stream()
或者parallelStream()
方法创建流:
import java.util.stream.Stream;Stream<String> s1 = Arrays.asList("a","b","c").stream();
Stream<String> s2 = Arrays.asList("a","b","c").parallelStream();
java.util.stream.Stream
是一个interface
, 各种管道中间操作的返回值都是它的实现类, 这允许我们方便地进行参数传递.
Stream
的静态方法of()
也可以用来创建流:
Stream.of(new int[]{1,2,3});
Arrays
也提供了创建流的静态方法stream()
:
Arrays.stream(new int[]{1,2,3})
一些类也提供了创建流的方法:
IntStream.range(start, stop);BufferedReader.lines();
Random.ints();
中间操作
流操作是惰性执行的, 中间操作会返回一个新的流对象, 当执行终点操作时才会真正进行计算.下面介绍流的中间操作. 除非传入的操作函数有副作用, 函数本身不会对数据源进行任何修改.
distinct
distinct
保证数据源中的重复元素在结果中只出现一次, 它使用equals()
方法判断两个元素是否相等.
List<String> list = Stream.of("a","b","c","b") .distinct()
.collect(Collectors.toList());
filter
filter
根据传入的断言函数对所有元素进行检查, 只有使断言函数返回真的元素才会出现在结果中. filter
不会对数据源进行修改.
List<Integer> list = IntStream.range(1,10).boxed() .filter( i -> i % 2 == 0)
.collect(Collectors.toList());
java.util.Objects
提供了空元素过滤的工具:
List<MyItem> list = items.stream() .filter(Objects::nonNull)
.collect(Collectors.toList());
map
map
方法根据传入的mapper函数对元素进行一对一映射, 即数据源中的每一个元素都会在结果中被替换(映射)为mapper函数的返回值.
List<String> list = Stream.of('a','b','c') .map( s -> s.hashCode())
.collect(Collectors.toList());
flatMap
与map
不同flatMap
进行多对一映射, 它要求若数据源的元素类型为R
, 则mapper函数的返回值必须为Stream<R>
.
flatMap
会使用mapper函数将数据源中的元素一一映射为Stream
对象, 然后把这些Stream
拼装成一个流.因此我们可以使用flatMap
进行合并列表之类的操作:
List<Integer> list = Stream.of( Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
)
.flatMap(l -> l.stream())
.collect(Collectors.toList());
peek
peek
方法会对数据源中所有元素进行给定操作, 但在结果中仍然是数据源中的元素. 通常我们利用操作的副作用, 修改其它数据或进行输入输出.
List<String> list = Stream.of('a','b','c') .map(s -> System.out.println(s))
.collect(Collectors.toList());
sorted
sorted
方法用于对数据源进行排序:
List<Integer> list = Arrays.asList(1,2,3,4,5,6).stream() .sorted((a, b) -> a-b)
.collect(Collectors.toList());
使用java.util.Comparator
是更方便的方法, 默认进行升序排序:
class Item { int val;
public Item(int val) { this.val = val; }
public int getVal() { return val; }
}
List<Item> list = Stream.of(
new Item(1),
new Item(2),
new Item(3)
)
.sorted(Comparator.comparingInt(Item::getVal))
.collect(Collectors.toList());
使用reversed()
方法进行降序排序:
List<Item> list = Stream.of( new Item(1),
new Item(2),
new Item(3)
)
.sorted(Comparator.comparingInt(Item::getVal).reversed())
.collect(Collectors.toList());
limit
limit(int n)
当流中元素数大于n时丢弃超出的元素, 否则不进行处理, 达到限制流长度的目的.
skip
skip(int)
返回丢弃了前n个元素的流. 如果流中的元素小于或者等于n,则返回空的流
终点操作
reduce
reduce(accumulator)
是最基本的终点操作之一, 操作函数accumulator
接受两个参数x
,y
返回r
.
reduce
首先将数据源中的两个元素x1
和x2
传给accumulator
得到r1
, 然后将r1
和x3
传入得到r2
. 如此进行直到处理完整个数据流.
reduce
方法还可以接受一个参数代替x1
作为起始值:
Integer sum = Stream.of(1,2,3,4,5).reduce(0, (x, y) -> x +y);String concat = Stream.of("a", "b", "c", "d").reduce("", String::concat);
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0)
.reduce(Double.MAX_VALUE, Double::min);
collect
collect
是使用最广泛的终点操作, 也上文中多次出现:
List<String> list = Stream.of("a","b","c","b") .distinct()
.collect(Collectors.toList())
toList()
将流转换为List
实例, 是最常见的用法, java.util.Collectors
类中还有求和, 计算均值, 取最值, 字符串连接等多种收集方法.
forEach
forEach
方法对流中所有元素执行给定操作, 没有返回值.
Stream.of(1,2,3,4,5).forEach(System.out::println);
其它
count()
返回流中的元素数toArray()
: 转换为数组
并发问题
除非显式地创建并行流, 否则默认创建的都是串行流.Collection.stream()
为集合创建串行流,而Collection.parallelStream()
创建并行流.
stream.parallel()
方法可以将串行流转换成并行流,stream.sequential()
方法将流转换成串行流.
流可以在非线程安全的集合上创建, 流操作不应该对非线程安全的数据源产生任何副作用, 否则将发生java.util.ConcurrentModificationException
异常.
List<String> list = new ArrayList(Arrays.asList("a", "b"));list = list.stream().forEach(s -> l.add("c")); // cause exception
对于线程安全的容器不会存在这个问题:
List<String> list = new CopyOnWriteArrayList<>(Arrays.asList("a", "b"));list = list.stream().forEach(s -> l.add("c")); // safe operation
当然作者建议Stream操作不要对数据源进行任何修改. 当然, 修改其它数据或者输入输出是允许的:
list.stream().forEach(s -> { set.add(s);
System.out.println(s);
});
理想的管道操作应该是无状态且与访问顺序无关的. 无状态是指操作的结果只与输入有关, 下面即是一个有状态的操作示例:
State state = getState();List<String> list = new ArrayList(Arrays.asList("a", "b"));
list = list.stream().map(s -> {
if (state.isReady()) {
return s;
}
else {
return null;
}
});
无状态的操作保证无论系统状态如何管道的行为不变, 与顺序无关则有利于进行并行计算.
函数式接口
函数式接口会将签名匹配的函数对象(lambda表达式或方法)视作接口的实现。
@FunctionalInterfaceinterface Greeter
{
void hello(String message);
}
函数式接口中有且只有一个非抽象方法。
Greeter greeter = message -> System.out.println("Hello " + message);
这在 Java 8 之前通常使用匿名内部类实现的:
Greeter greeter = new Greeter() { @Override
public void hello(String message) {
System.out.println("Hello " + message);
}
};
Java 8 将已有的一些接口实现为函数式接口:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.util.Comparator
- java.lang.reflect.InvocationHandler
- java.io.FileFilter
- java.nio.file.PathMatcher
java.util.function
中定义了一些常用的函数式接口:
- Consumer: 接受参数无返回
Consumer<T>
->void accept(T t)
;BiConsumer<T,U>
->void accept(T t, U u);
DoubleConsumer
->void accept(double value);
- Supplier: 不接受参数有返回
Supplier<T>
->T get();
DoubleSupplier
->double getAsDouble();
- Function: 接受参数并返回
Function<T, R>
->R apply(T t);
BiFunction<T, U, R>
->R apply(T t, U u);
DoubleFunction<R>
->R apply(double value);
DoubleToIntFunction
->int applyAsInt(double value);
BinaryOperator<T>
extendsBiFunction<T,T,T>
- Predicate: 接受参数返回boolean
Predicate<T>
->boolean test(T t);
BiPredicate<T, U>
->boolean test(T t, U u);
DoublePredicate
->boolean test(double value);
默认构造器可以作为supplier: Supplier<Item> supplier = Item::new;
以上是 Java8 Stream简介 的全部内容, 来源链接: utcz.com/z/392852.html