Java8——java.util.stream.Stream类方法总结

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)

其中,BiConsumerBiFunction差不多,也是二元操作,但是没有返回值。

所以: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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值