java.util.stream.Stream
filter
Stream<T> filter(Predicate<? super T> predicate)
按给定Predicate过滤并返回一个steam,这是一个中间操作
map
<R> Stream<R> map(Function<? super T,? extends R> mapper)
对每个元素都调用mapper.apply()方法,这是一个中间操作
mapToInt
IntStream mapToInt(ToIntFunction<? super T> mapper)
其中:ToIntFunction
:
@FunctionalInterface
public interface ToIntFunction<T>{
int applyAsInt(T value);
}
所以mapToInt
方法会将元素转化为int类型,这个方法可以用来提取对象中的int类型属性值,或者将某个对象转换成int类型等操作,如:
List<Person> persons = Arrays.asList(
new Person("张三",16,Person.Gender.Man),
new Person("李四",26,Person.Gender.Man),
new Person("王五",36,Person.Gender.Woman),
new Person("郑六",46,Person.Gender.Man),
new Person("田七",66,Person.Gender.Woman)
);
Stream<Person> stream = persons.stream();
// 提取出年龄并打印
stream.mapToInt(p -> p.getAge()).forEach(age -> log.info(String.valueOf(age)));
这是一个中间操作
mapToLong
,mapToDouble
与mapToInt
同理
flatMap
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
注意看mapper的类型是:Function<? super T,? extends Stream<? extends R>>
这意味着在遍历每个元素并对其调用mapper.apply()方法,该方法返回的是Stream
类型的对象,然后对每一个Straem
调用其map
方法,将每个Stream
里面的元素转移到flatMap
方法返回的Stream对象中。
该方法用于提取Collection<Collection<T>>
类型的数据,如:
List<String> innerL = Arrays.asList("a","b","c","d");
List<List<String>> outL = Arrays.asList(innerL,innerL,innerL);
Stream<String> finalStream = outL.stream().flatMap(
list -> list.stream() //返回outL列表内每个元素的Stream
);// 对outL列表内每个元素的Stream调用map方法,提取其中的内容,并放入finalStream中
finalStream.forEach(log::info);
flatMapToInt
,flatMapToLong
,flatMapToDouble
flatMap
+ mapToXXX
distinct
Stream<T> distinct()
使用Object.equals(Object)
去重
sorted
Stream<T> sorted()
:
对元素进行自然排序,如果元素类型没有实现Comparable
接口,将会抛出java.lang.ClassCastException
异常
Stream<T> sorted(Comparator<? super T> comparator)
:
使用给定比较器进行排序
peek
Stream<T> peek(Consumer<? super T> action)
对元素进行给定的操作。
limit
Stream<T> limit(long maxSize)
设置最大元素个数
skip
Stream<T> skip(long n)
跳过前n个元素
forEach
void forEach(Consumer<? super T> action)
遍历每个元素并对其进行指定操作,不保证按照遍历顺序(encounter order)进行action.apply()操作
forEachOrdered
void forEachOrdered(Consumer<? super T> action)
遍历每个元素并对其进行指定操作,且按照遍历顺序依次操作一个元素。
toArray
Object[] toArray()
返回一个存放所有元素的Object
数组
<A> A[] toArray(IntFunction<A[]> generator)
:
其中IntFunction
:
@FunctionalInterface
public interface IntFunction<R>{
R apply(int value)
}
这里toArray的用法是:
Person[] pers = persons.stream.toArray(i -> new Person[i]);
//或者是
Person[] pers = persons.stream.toArray(Person[]::new);
reduce
T reduce(T identity, BinaryOperator<T> accumulator)
其中:
@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T>{
public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
}
public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
Objects.requireNonNull(comparator);
return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
}
}
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u);
default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t, U u) -> after.apply(apply(t, u));
}
}
BinaryOperatior对对象进行二元操作,并返回一个相同类型的对象,如:
Person result = persons.stream().reduce(new Person("小二",33,Person.Gender.MAN),(p1,p2)->p1.getAge() > p2.getAge()?p1:p2);
上面的操作与使用一趟冒泡排序从“小二”开始与persons列表进行比较,找出年龄最大的Person对象。
Optional<T> reduce(BinaryOperator<T> accumulator)
与第一个方法类似
collect
<R> R collect(Supplier<R> supplier,BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)
其中,BiConsumer
与BiFunction
差不多,也是二元操作,但是没有返回值。
所以:collect
也与reduce
类似,但是所有的accumulator操作都是在更新对象的状态,并不会反回一个对象,例如:
Person result = stream.collect(Person::new,(p1,p2)->p1.setSalary(p1.getSalary()+p2.getSalary()),(p1,p2)->p1.setSalary(p1.setSalary()+p2.setSalary()));
log.info(String.valueOf(result.getAge()));
上面新建了一个Person
对象,并且其工资为列表中所有Person
对象工资之和。
min
,max
,count
按指定比对方法获取所有元素中的最大、最小元素,获取元素的个数
anyMatch
,allMatch
,noneMatch
按照给定的Predicate
,判断是否有元素匹配、是否所有元素匹配或是否所有元素都不匹配
findFirst
返回一个Optional
,其中包含Stream
的第一个元素,如果Stream
为empty,则返回一个空的Optional
findAny
返回一个包含任意元素的Optional
empty
返回一个空的连续的Stream
of
static <T> Stream<T> of(T t)
返回一个包含一个元素的Stream
static <T> Stream<T> of(T... values)
返回包含指定元素的Stream