Code Quality Rank: L3
Programming language: Java
Latest version: v0.7.3

StreamEx alternatives and similar libraries

Based on the "Functional Programming" category

  • Javaslang

    VAVR (formerly called Javaslang) is a non-commercial, non-profit object-functional library that runs with Java 8+. It aims to reduce the lines of code and increase code quality.
  • Functional Java

    Implements numerous basic and advanced programming abstractions that assist composition-oriented development.
  • jOOλ

    Extension to Java 8 which aims to fix gaps in lambda, providing numerous missing types and a rich set of sequential Stream API additions.
  • cyclops-react

    Monad and stream utilities, comprehensions, pattern matching, functional extensions for all JDK collections, future streams, trampolines and much more.
  • λ

    functional-programming, lenses, lambda, functor, monad, semigroup, monoid, coproduct, heterogeneous-maps, profunctors, bifunctors, either, traversable, try-monad, algebraic-data-types, tuples, hlist, maybe-monad, optics
  • derive4j

    Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching, morphisms.
  • protonpack

    Collection of stream utilities.
  • underscore-java

    java port of Underscore.js
  • Fugue

    Functional extensions to Guava.
  • Faux Pas

    Library that simplifies error handling by circumventing the issue that none of the functional interfaces in the Java Runtime is allowed by default to throw checked exceptions.
  • Vavr

    Functional component library that provides persistent data types and functional control structures.

Do you think we are missing an alternative of StreamEx or a related project?

Add another 'Functional Programming' Library


StreamEx 0.7.3

Enhancing Java Stream API.

Maven Central Javadocs Build Status Coverage Status

This library defines four classes: StreamEx, IntStreamEx, LongStreamEx, DoubleStreamEx which are fully compatible with Java 8 stream classes and provide many additional useful methods. Also EntryStream class is provided which represents the stream of map entries and provides additional functionality for this case. Finally there are some new useful collectors defined in MoreCollectors class as well as primitive collectors concept.

Full API documentation is available here.

Take a look at the [Cheatsheet](wiki/CHEATSHEET.md) for brief introduction to the StreamEx!

Before updating StreamEx check the [migration notes](wiki/MIGRATION.md) and full list of [changes](wiki/CHANGES.md).

StreamEx library main points are following:

  • Shorter and convenient ways to do the common tasks.
  • Better interoperability with older code.
  • 100% compatibility with original JDK streams.
  • Friendliness for parallel processing: any new feature takes the advantage on parallel streams as much as possible.
  • Performance and minimal overhead. If StreamEx allows to solve the task using less code compared to standard Stream, it should not be significantly slower than the standard way (and sometimes it's even faster).


Collector shortcut methods (toList, toSet, groupingBy, joining, etc.)

List<String> userNames = StreamEx.of(users).map(User::getName).toList();
Map<Role, List<User>> role2users = StreamEx.of(users).groupingBy(User::getRole);
StreamEx.of(1,2,3).joining("; "); // "1; 2; 3"

Selecting stream elements of specific type

public List<Element> elementsOf(NodeList nodeList) {
    return IntStreamEx.range(nodeList.getLength())

Adding elements to stream

public List<String> getDropDownOptions() {
    return StreamEx.of(users).map(User::getName).prepend("(none)").toList();

public int[] addValue(int[] arr, int value) {
    return IntStreamEx.of(arr).append(value).toArray();

Removing unwanted elements and using the stream as Iterable:

public void copyNonEmptyLines(Reader reader, Writer writer) throws IOException {
    for(String line : StreamEx.ofLines(reader).remove(String::isEmpty)) {

Selecting map keys by value predicate:

Map<String, Role> nameToRole;

public Set<String> getEnabledRoleNames() {
    return StreamEx.ofKeys(nameToRole, Role::isEnabled).toSet();

Operating on key-value pairs:

public Map<String, List<String>> invert(Map<String, List<String>> map) {
    return EntryStream.of(map).flatMapValues(List::stream).invert().grouping();

public Map<String, String> stringMap(Map<Object, Object> map) {
    return EntryStream.of(map).mapKeys(String::valueOf)

Map<String, Group> nameToGroup;

public Map<String, List<User>> getGroupMembers(Collection<String> groupNames) {
    return StreamEx.of(groupNames).mapToEntry(nameToGroup::get)

Pairwise differences:

DoubleStreamEx.of(input).pairMap((a, b) -> b-a).toArray();

Support of byte/char/short/float types:

short[] multiply(short[] src, short multiplier) {
    return IntStreamEx.of(src).map(x -> x*multiplier).toShortArray(); 

Define custom lazy intermediate operation recursively:

static <T> StreamEx<T> scanLeft(StreamEx<T> input, BinaryOperator<T> operator) {
        return input.headTail((head, tail) -> scanLeft(tail.mapFirst(cur -> operator.apply(head, cur)), operator)

And more!


This project is licensed under Apache License, version 2.0


Releases are available in Maven Central

Before updating StreamEx check the [migration notes](wiki/MIGRATION.md) and full list of [changes](wiki/CHANGES.md).


Add this snippet to the pom.xml dependencies section:



Add this snippet to the build.gradle dependencies section:

implementation 'one.util:streamex:0.7.3'

Pull requests are welcome.

*Note that all licence references and agreements mentioned in the StreamEx README section above are relevant to that project's source code only.