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

关注

原创最新推荐文章于 2026-03-20 00:42:07 发布 1.5k 阅读 AI 写同款· GEO 优化 ›

【java学习】java8新特性：stream、Lambda函数、接口的默认方法和类方法、函数式接口、Optional、DateTime 1，概念java.util.stream是java8新特性。 java.util.stream与java.io包里的 InputStream 和 OutputStream 是完全不同的概念。 Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bul............ 阅读详情

`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()));