# Awesome Java 8 [](https://travis-ci.org/tedyoung/awesome-java8) [](https://github.com/sindresorhus/awesome)
A truly curated list of useful, if not amazingly awesome, tools, libraries, frameworks, and other resources that take advantage of (or even require) Java 8 features, such as Lambdas, or have a more modern approach to writing Java code. Those that **require** Java 8 are marked with an :8ball: emoji (for "eight ball" or sometimes "billiards").
If you want a larger list of Java resources not specific to Java 8, check out [Awesome Java](https://github.com/akullpp/awesome-java).
----
# Contents
- [Libraries and Frameworks](#libraries-and-frameworks)
- [Caching libraries](#caching-libraries)
- [Distributed Systems libraries](#distributed-systems-libraries)
- [Functional libraries](#functional-libraries)
- [General-purpose libraries](#general-purpose-libraries)
- [Interoperability libraries](#interoperability-libraries)
- [Microservices](#microservices)
- [Networking libraries](#networking-libraries)
- [Persistence libraries](#persistence-libraries)
- [Reactive libraries](#reactive-libraries)
- [Streams libraries](#streams-libraries)
- [Testing](#testing)
- [Web App/API frameworks](#web-appapi-frameworks)
- [Tools](#tools)
- [Books](#books)
----
# Libraries and Frameworks
Libraries and frameworks become part of your runtime artifact. Libraries consist of code that you call, whereas frameworks require that you inherit from classes or implement interfaces defined in that framework. *Modern Java* prefers the delegation model of Libraries vs. the inheritance model of frameworks, however in some cases, frameworks might be worth the inheritance cost, e.g., web frameworks.
## Caching Libraries
* [Caffeine](https://github.com/ben-manes/caffeine) - High performance Java 8-based in-memory caching library providing a near optimal "hit rate". Well-documented and flexible. :8ball:
## Distributed Systems libraries
Libraries that support distributed systems, e.g., queues, key-value stores, and quorum/consensus.
* [Atomix](http://atomix.io/atomix/) - Event-driven framework for coordinating fault-tolerant distributed systems built on the Raft consensus algorithm. :8ball:
## Functional libraries
Libraries that make Java 8 more functional, especially filling in the gaps in streams.
For strictly stream enhancements, go to the [Streams libraries](#streams-libraries) section.
* [Derive4J](https://github.com/derive4j/derive4j) - Code generator for user-defined algebraic data types (aka sum types) based on an enhanced "visitor" pattern. Provides structural pattern matching, laziness, functional setters (return a copy of an object with one field modified) & more. :8ball:
* [Vavr](http://www.vavr.io/) - Adds the notion of Tuples, along with immutable Values and Pattern Matching, to make it easier to write more functional Java code. (Formerly known as Javaslang.) :8ball:
* [jOOλ](https://github.com/jOOQ/jOOL) - Part of the jOOQ series of libraries, provides more Functions, Tuples, and `Seq` that provides methods like `crossJoin()`, `join()`, and `groupBy()`. :8ball:
* [NoException](https://noexception.machinezoo.com/) - Allows checked exceptions in functional interfaces and converts exceptions to Optional return. :8ball:
* [ProtonPack](https://github.com/poetix/protonpack) - Offers about a dozen utilities for `Stream`, e.g., `takeWhile`, `zip`, `aggregate`, and a `unique` collector. :8ball:
## General-purpose libraries
For libraries with many features that don't fit in a single category. _Honestly, this section was just created so that it can hold Guava, which as of [Release 21](https://github.com/google/guava/wiki/Release21) requires Java 8+._
* [Guava](https://github.com/google/guava) - One of the most widely used and well-written general-purpose Java libraries. As of Release 21, only works with Java 8 (or later). :8ball:
## Interoperability libraries
Not sure what to call these other than interoperability libraries, i.e., libraries that make it easier to work with existing libraries that Java 8 provides. I could be convinced to put this under Functional libraries...
* [Cyclops](https://github.com/aol/cyclops) - Very modular, so only include what you need. From function exception handling (`try`), to generic monad operations, to pattern matching. Specific integrations to Javaslang, functionaljava, and Guava. :8ball:
## Microservices
While the term can sometimes be ambiguous, hopefully it'll become more clear as new libraries and frameworks become available. This section may include entire frameworks, or libraries that help with coordinating and connecting separately deployed services (aka microservices).
For HTTP-based services, see [Web App/API frameworks](#web-appapi-frameworks).
* [Apollo](http://spotify.github.io/apollo/) - A library for writing HTTP microservices that focuses on composability and simplicity, with high performance using modern Java idioms and features. :8ball:
* [SnoopEE](https://github.com/ivargrimstad/snoop) - While this is "experimental", it's worth looking at if you're coming to microservices from a "slimmed down" Java EE point of view and need something to handle service discovery. This was shown in a JavaOne 2015 conference talk [here](https://www.youtube.com/watch?v=REuBLPTeFDg). :8ball:
## Networking libraries
Perhaps this belongs in "distributed systems libraries", since dist-sys requires resiliency, though I like calling out resiliency as it's often overlooked.
I'll leave this here for now until someone has an opinion.
* [Resilience4j](https://github.com/resilience4j/resilience4j) - A lightweight, easy-to-use, fault-tolerance library designed for Java8 and functional programming (inspired by Netflix's Hystrix).
In addition to circuit-breakers, also retries, rate-limiting, and metrics. :8ball:
## Persistence libraries
* [Speedment](https://github.com/speedment/speedment) - A fluent database access library that looks just like Java 8 code, using the Stream API for querying. Supports MySQL, MariaDB, and PostgreSQL. :8ball:
## Reactive libraries
Focused on "pulling" items from a stream. There may be overlap between these libraries and the Functional ones (above), but the ones here are primarily/exclusively focused on the [Reactive](http://www.reactive-streams.org/) way of thinking about streams.
* [Cyclops React](https://github.com/aol/cyclops-react) - A library that focuses on users needing async and lazy streams (formerly Simple React). Very well documented with lots of diagrams (yay!). :8ball:
* [Project Reactor](http://projectreactor.io/) - A second-generation Reactive library for building non-blocking applications on the JVM based on the Reactive Streams Specification.
It directly interacts with the Java 8 functional API, Completable Future, Stream and Duration. :8ball:
## Streams libraries
These are libraries that enhance the existing Java 8 Streams, but aren't trying to define a completely new API.
I could be convinced to put these under the [Functional](#functional-libraries) libraries, but until then...
* [StreamEx](https://github.com/amaembo/streamex) - Does what it says: enhances the Java 8 streams. The ["cheat sheet"](https://github.com/amaembo/streamex/blob/master/CHEATSHEET.md) is really nice: if you know what you want (e.g., swap keys and values coming from entries in a map), it tells you how to get it. :8ball:
## Testing
* [AssertJ](http://joel-costigliola.github.io/assertj/index.html) - Fluent assertions for Java unit testing, with the 3.0 release requiring Java 8. :8ball:
* [Lambda Behave](http://richardwarburton.github.io/lambda-behave/) - BDD-oriented framework that leverages lambdas to make tests more "behavioral". If you've seen Jasmine or Spock, thi
