https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Return to Java, Awesome JVM, Awesome Python, Awesome Java DevOps, Java Bibliography, Java DevOps, Java DevOps Bibliography, and Awesome lists

A curated list of awesome Java frameworks, Java libraries and Java software.

• Bean Mapping: Java Bean Mapping
• Build: Java build
• Bytecode Manipulation: Java bytecode manipulation
• Caching: Java caching
• CLI: Java cli
• Cluster Management: Java cluster management
• Code Analysis: Java code analysis
• Code Coverage: Java code coverage
• Code Generators: Java code generators
• Compiler compiler: Java compiler compiler
• Computer Vision: Java computer vision
• Configuration: Java configuration
• Constraint Satisfaction Problem Solver: Java constraint satisfaction problem solver
• CSV: Java csv
• Data Structures: Java data structures
• Database: Java database
• Date and Time: Java date and time
• Dependency Injection: Java dependency injection
• Development: Java development
• Distributed Applications: Java distributed applications
• Distributed Transactions: Java distributed transactions
• Distribution: Java distribution
• Document Processing: Java document processing
• Financial: Java financial
• Formal Verification: Java formal verification
• Functional Programming: Java functional programming
• Game Development: Java game development
• Geospatial: Java geospatial
• GUI: Java gui
• High Performance: Java high performance
• HTTP Clients: Java http clients
• Hypermedia Types: Java hypermedia types
• IDE: Java ide
• Imagery: Java imagery
• Introspection: Java introspection
• Job Scheduling: Java job scheduling
• JSON: Java json
• JVM and JDK: Java jvm and jdk
• Logging: Java logging
• Machine Learning: Java machine learning
• Messaging: Java messaging
• Microservice: Java microservice
• Miscellaneous: Java miscellaneous
• Mobile Development: Java mobile development
• Monitoring: Java monitoring
• Native: Java native
• Natural Language Processing: Java natural language processing
• Networking: Java networking
• ORM: Java orm
• PaaS: Java paas
• PDF: Java pdf
• Performance analysis: Java performance analysis
• Platform: Java platform
• Processes: Java processes
• Reactive libraries: Java reactive libraries
• REST Frameworks: Java rest frameworks
• Science: Java science
• Search: Java search
• Security: Java security
• Serialization: Java serialization
• Server: Java server
• Template Engine: Java template engine
• Testing: Java testing
• Utility: Java utility
• Version Managers: Java version managers
• Web Crawling: Java web crawling
• Web Frameworks: Java web frameworks
• Workflow Orchestration Engines: Java workflow orchestration engines
• Resources: Java resources
• Related Awesome Lists: Java awesome lists
• Communities: Java communities
• Frontends: Java frontends
• Influential Books: Java influential books
• Podcasts and Screencasts: Java podcasts and screencasts
• People: Java people
• Websites: Java websites

Java Bean Mapping - Java Frameworks that ease Java bean mapping

• dOOv - (https://github.com/doov-io/doov) - Provides fluent API for typesafe domain model validation and mapping. It uses annotations, code generation and a type safe DSL to make bean validation and mapping fast and easy.
• JMapper - (https://github.com/jmapper-framework/jmapper-core) - Uses byte code manipulation for lightning-fast mapping. Supports annotations and API or XML configuration.
• MapStruct - (https://github.com/mapstruct/mapstruct) - Code generator that simplifies mappings between different bean types, based on a convention-over-configuration approach.
• ModelMapper - (https://github.com/modelmapper/modelmapper) - Intelligent object mapping library that automatically maps objects to each other.
• Orika - (https://github.com/orika-mapper/orika) - JavaBean-mapping framework that recursively copies (among other capabilities) data from one object to another.
• reMap - (https://github.com/remondis-it/remap) - Lambda and method handle-based mapping which requires code and not annotations if objects have different names.
• Selma - (https://github.com/xebia-france/selma) - Annotation processor-based bean mapper.

Java Build - Java Tools that handle the build cycle and dependencies of an application

• Apache Maven - (https://maven.apache.org) - Declarative build and dependency management that favors convention over configuration. It might be preferable to Apache Ant, which uses a rather procedural approach and can be difficult to maintain.
• Bazel - (https://bazel.build) - Tool from Google that builds code quickly and reliably.
• Buck - (https://github.com/facebook/buck) - Encourages the creation of small, reusable modules consisting of code and resources.
• Gradle - (https://gradle.org) - Incremental builds programmed via Groovy instead of declaring XML. Works well with Maven's dependency management.

Java Bytecode Manipulation - Java Libraries to manipulate bytecode programmatically

• ASM - (https://asm.ow2.io) - All-purpose, low-level bytecode manipulation and analysis.
• Byte Buddy - (https://bytebuddy.net) - Further simplifies bytecode generation with a fluent API.
• bytecode-viewer - (https://github.com/Konloch/bytecode-viewer) - Java 8 Jar & Android APK reverse engineering suite. (GPL-3.0-only)
• Byteman - (https://byteman.jboss.org) - Manipulate bytecode at runtime via DSL (rules); mainly for testing/troubleshooting. (LGPL-2.1-or-later)
• cglib - (https://github.com/cglib/cglib) - Bytecode generation library.
• Javassist - (https://github.com/jboss-javassist/javassist) - Tries to simplify bytecode editing.
• Mixin - (https://github.com/SpongePowered/Mixin) - Manipulate bytecode at runtime using real Java code.
• Perses - (https://github.com/nicolasmanic/perses) - Dynamically injects failure/latency at the bytecode level according to principles of chaos engineering.

Java Caching - Java Libraries that provide caching facilities

• cache2k - (https://cache2k.org) - In-memory high performance caching library.
• Caffeine - (https://github.com/ben-manes/caffeine) - High-performance, near-optimal caching library.
• Ehcache - (http://www.ehcache.org) - Distributed general-purpose cache.
• Infinispan - (https://infinispan.org) - Highly concurrent key/value datastore used for caching.

Java CLI - Java Libraries for everything related to the CLI

• ASCII Table - (https://github.com/vdmeer/asciitable) - Library to draw tables in ASCII.
• Airline - (https://github.com/airlift/airline) - Annotation-based framework for parsing Git-like command-line arguments.
• args4j - (http://args4j.kohsuke.org) - Small library to parse command-line arguments.
• Jansi - (https://github.com/fusesource/jansi) - ANSI escape codes to format console output.
• Java ASCII Render - (https://github.com/indvd00m/java-ascii-render) - Graphical primitives for the console.
• JCommander - (http://jcommander.org) - Command-line argument-parsing framework with custom types and validation via implementing interfaces.
• jbock - (https://github.com/jbock-java/jbock) - Reflectionless command line parser.
• Jexer - (https://gitlab.com/klamonte/jexer) - Advanced console (and Swing) text user interface (TUI) library, with mouse-draggable windows, built-in terminal window manager, and sixel image support. Looks like [Turbo Vision]] - (https://en.wikipedia.org/wiki/Turbo_Vision).
• JLine - (https://github.com/jline/jline3) - Includes features from modern shells like completion or history.
• JOpt Simple - (https://jopt-simple.github.io/jopt-simple) - Fluent parser that uses the POSIX#getopt and GNU#getopt_long syntaxes.
• picocli - (https://picocli.info) - ANSI colors and styles in usage help with annotation-based POSIX/GNU/any syntax, subcommands, strong typing for both options and positional args.
• Text-IO - (https://github.com/beryx/text-io) - Aids the creation of full console-based applications.
• Lanterna - (https://github.com/mabe02/lanterna) - Easy console text-GUI library, similar to curses. (LGPL-3.0-only)

Java Cluster Management - Java Frameworks that can dynamically manage applications inside of a cluster

• Apache Aurora - (https://aurora.apache.org) - Mesos framework for long-running services and cron jobs.
• Singularity - (http://getsingularity.com) - Mesos framework that makes deployment and operations easy. It supports web services, background workers, scheduled jobs, and one-off tasks.

Java Code Analysis - Java Tools that provide metrics and quality measurements

• Checkstyle - (https://github.com/checkstyle/checkstyle) - Static analysis of coding conventions and standards. (LGPL-2.1-or-later)
• Error Prone - (https://github.com/google/error-prone) - Catches common programming mistakes as compile-time errors.
• Infer - (https://github.com/facebook/infer) - Modern static analysis tool for verifying the correctness of code.
• jQAssistant - (https://jqassistant.org) - Static code analysis with Neo4J-based query language. (GPL-3.0-only)
• NullAway - (https://github.com/uber/NullAway) - Eliminates NullPointerExceptions with low build-time overhead.
• PMD - (https://github.com/pmd/pmd) - Source code analysis for finding bad coding practices.
• SonarJava - (https://github.com/SonarSource/sonar-java) - Static analyzer for SonarQube & SonarLint. (LGPL-3.0-only)
• Spoon - (https://github.com/INRIA/spoon) - Library for analyzing and transforming Java source code.
• Spotbugs - (https://github.com/spotbugs/spotbugs) - Static analysis of bytecode to find potential bugs. (LGPL-2.1-only)

Java Code Coverage - Java Frameworks and tools that enable code coverage metrics collection for test suites

• Clover - (https://www.atlassian.com/software/clover) - Relies on source-code instrumentation instead of bytecode instrumentation.
• Cobertura - (https://cobertura.github.io/cobertura) - Relies on offline (or static) bytecode instrumentation and class loading to collect code coverage metrics. (GPL-2.0-only)
• JaCoCo - (https://www.eclemma.org/jacoco) - Framework that enables collection of code coverage metrics, using both offline and runtime bytecode instrumentation.

Java Code Generators - Java Tools that generate patterns for repetitive code in order to reduce verbosity and error-proneness

• ADT4J - (https://github.com/sviperll/adt4j) - JSR-269 code generator for algebraic data types.
• Auto - (https://github.com/google/auto) - Generates factory, service, and value classes.
• Bootify - (https://bootify.io) - Browser-based Spring Boot app generation with JPA model and REST API.
• FreeBuilder - (https://github.com/inferred/FreeBuilder) - Automatically generates the Builder pattern.
• Geci - (https://github.com/verhas/javageci) - Discovers files that need generated code, updates automatically and writes to the source with a convenient API.
• Immutables - (https://immutables.github.io) - Annotation processors to generate simple, safe and consistent value objects.
• JavaPoet - (https://github.com/square/javapoet) - API to generate source files.
• JHipster - (https://github.com/jhipster/generator-jhipster) - Yeoman source code generator for Spring Boot and AngularJS.
• Joda-Beans - (https://www.joda.org/joda-beans) - Small framework that adds queryable properties to Java, enhancing JavaBeans.
• JPA Buddy - (https://www.jpa-buddy.com) - Plugin for IntelliJ IDEA. Provides visual tools for generating JPA entities, Spring Data JPA repositories, Liquibase changelogs and SQL scripts. Offers automatic Liquibase/Flyway script generation by comparing model to DB, and reverse engineering JPA entities from DB tables.
• Lombok - (https://projectlombok.org) - Code generator that aims to reduce verbosity.
• Record-Builder - (https://github.com/Randgalt/record-builder) - Companion builder class, withers and templates for Java records.
• Telosys - (https://www.telosys.org) - Simple and light code generator available as an Eclipse Plugin and also as a CLI.

Java Compiler - Java Frameworks that help to create parsers, interpreters or compilers

• ANTLR - (https://www.antlr.org) - Complex full-featured framework for top-down parsing.
• JavaCC - (https://javacc.github.io/javacc) - Parser generator that generates top-down parsers. Allows lexical state switching and permits extended BNF specifications.
• JFlex - (https://jflex.de) - Lexical analyzer generator.

Java Computer Vision - Java Libraries which seek to gain high level information from images and videos

• BoofCV - (https://boofcv.org) - Library for image processing, camera calibration, tracking, SFM, MVS, 3D vision, QR Code and much more.
• ImageJ - (https://imagej.net/ImageJ) - Medical image processing application with an API.
• JavaCV - (https://github.com/bytedeco/javacv) - Java interface to OpenCV, FFmpeg, and much more.

Java Configuration - Java Libraries that provide external configuration

• centraldogma - (https://github.com/line/centraldogma) - Highly-available version-controlled service configuration repository based on Git, ZooKeeper and HTTP/2.
• cfg4j - (https://github.com/cfg4j/cfg4j) - Modern configuration library for distributed apps written in Java.
• config - (https://github.com/lightbend/config) - Configuration library supporting Java properties, JSON or its human optimized superset HOCON.
• Configurate - (https://github.com/SpongePowered/Configurate) - Configuration library with support for various configuration formats and transformations.
• dotenv - (https://github.com/shyiko/dotenv) - Twelve-factor configuration library which uses environment-specific files.
• ini4j - (http://ini4j.sourceforge.net) - Provides an API for handling Windows' INI files.
• KAConf - (https://github.com/mariomac/kaconf) - Annotation-based configuration system for Java and Kotlin.
• microconfig - (https://microconfig.io) - Configuration system designed for microservices which helps to separate configuration from code. The configuration for different services can have common and specific parts and can be dynamically distributed.
• owner - (https://github.com/lviggiano/owner) - Reduces boilerplate of properties.

Java Constraint Satisfaction Problem Solver - Java Libraries that help with implementing optimization and satisfiability problems

• Choco - (https://choco-solver.org) - Off-the-shelf constraint satisfaction problem solver that uses constraint programming techniques.
• JaCoP - (https://github.com/radsz/jacop) - Includes an interface for the FlatZinc language, enabling it to execute MiniZinc models. (AGPL-3.0)
• OptaPlanner - (https://www.optaplanner.org) - Business planning and resource scheduling optimization solver.

Java CSV - Java Frameworks and libraries that simplify reading/writing CSV data

• FastCSV - (https://github.com/osiegmar/FastCSV) - Performance-optimized, dependency-free and RFC 4180 compliant.
• jackson-dataformat-csv - (https://github.com/FasterXML/jackson-dataformat-csv) - Jackson extension for reading and writing CSV.
• opencsv - (http://opencsv.sourceforge.net) - Simple CSV parser.
• Super CSV - (https://super-csv.github.io/super-csv) - Powerful CSV parser with support for Dozer, Joda-Time and Java 8.
• uniVocity-parsers - (https://github.com/uniVocity/univocity-parsers) - One of the fastest and most feature-complete parsers. Also comes with parsers for TSV and fixed-width records.

Java Data Structures - Java Efficient and specific data structures

• Apache Avro - (https://avro.apache.org) - Data interchange format with dynamic typing, untagged data, and absence of manually assigned IDs.
• Apache Orc - (https://orc.apache.org) - Fast and efficient columnar storage format for Hadoop-based workloads.
• Apache Parquet - (https://parquet.apache.org) - Columnar storage format based on assembly algorithms from Google's paper on Dremel.
• Apache Thrift - (https://thrift.apache.org) - Data interchange format that originated at Facebook.
• Big Queue - (https://github.com/bulldog2011/bigqueue) - Fast and persistent queue based on memory-mapped files.
• HyperMinHash-java - (https://github.com/LiveRamp/HyperMinHash-java) - Probabilistic data structure for computing union, intersection, and set cardinality in loglog space.
• Persistent Collection - (https://github.com/hrldcpr/pcollections) - Persistent and immutable analogue of the Java Collections Framework.
• Protobuf - (https://github.com/protocolbuffers/protobuf) - Google's data interchange format.
• RoaringBitmap - (https://github.com/RoaringBitmap/RoaringBitmap) - Fast and efficient compressed bitmap.
• SBE - (https://github.com/real-logic/simple-binary-encoding) - Simple Binary Encoding, one of the fastest message formats around.
• Tape - (https://github.com/square/tape) - Lightning-fast, transactional, file-based FIFO.
• Wire - (https://github.com/square/wire) - Clean, lightweight protocol buffers.

Java Database - Java Everything that simplifies interactions with the database

• Apache Calcite - (https://calcite.apache.org) - Dynamic data management framework. It contains many of the pieces that comprise a typical database management system.
• Apache Drill - (https://drill.apache.org) - Distributed, schema on-the-fly, ANSI SQL query engine for Big Data exploration.
• Apache Phoenix - (https://phoenix.apache.org) - High-performance relational database layer over HBase for low-latency applications.
• ArangoDB - (https://github.com/arangodb/arangodb-java-driver) - ArangoDB Java driver.
• Chronicle Map - (https://github.com/OpenHFT/Chronicle-Map) - Efficient, in-memory (opt. persisted to disk), off-heap key-value store.
• Debezium - (https://debezium.io) - Low latency data streaming platform for change data capture.
• druid - (https://druid.apache.org) - High-performance, column-oriented, distributed data store.
• eXist - (https://github.com/eXist-db/exist) - NoSQL document database and application platform. (LGPL-2.1-only)
• FlexyPool - (https://github.com/vladmihalcea/flexy-pool) - Brings metrics and failover strategies to the most common connection pooling solutions.
• Flyway - (https://flywaydb.org) - Simple database migration tool.
• H2 - (https://h2database.com) - Small SQL database notable for its in-memory functionality.
• HikariCP - (https://github.com/brettwooldridge/HikariCP) - High-performance JDBC connection pool.
• JDBI - (http://jdbi.org) - Convenient abstraction of JDBC.
• Jedis - (https://github.com/xetorthio/jedis) - Small client for interaction with Redis, with methods for commands.
• Jest - (https://github.com/searchbox-io/Jest) - Client for the Elasticsearch REST API.
• jetcd - (https://github.com/justinsb/jetcd) - Client library for etcd.
• Jinq - (https://github.com/my2iu/Jinq) - Typesafe database queries via symbolic execution of Java 8 Lambdas (on top of JPA or jOOQ).
• jOOQ - (https://www.jooq.org) - Generates typesafe code based on SQL schema.
• Leaf - (https://github.com/Meituan-Dianping/Leaf) - Distributed ID generate service.
• Liquibase - (http://www.liquibase.org) - Database-independent library for tracking, managing and applying database schema changes.
• MapDB - (http://www.mapdb.org) - Embedded database engine that provides concurrent collections backed on disk or in off-heap memory.
• MariaDB4j - (https://github.com/vorburger/MariaDB4j) - Launcher for MariaDB that requires no installation or external dependencies.
• Modality - (https://github.com/arkanovicz/modality) - Lightweight ORM with database reverse engineering features.
• Spring Data JPA MongoDB Expressions - (https://github.com/mhewedy/spring-data-jpa-mongodb-expressions) - Allows you to use MongoDB query language to query your relational database.
• Trino - (https://trino.io) - Distributed SQL query engine for big data.
• QuestDB - (https://github.com/questdb/questdb) - High-performance SQL database for time series. Supports InfluxDB line protocol, PostgreSQL wire protocol, and REST.
• QueryStream - (https://github.com/querystream/querystream) - Build JPA Criteria queries using a Stream-like API.
• Querydsl - (http://www.querydsl.com) - Typesafe unified queries.
• Realm - (https://github.com/realm/realm-java) - Mobile database to run directly inside phones, tablets or wearables.
• Redisson - (https://github.com/redisson/redisson) - Allows for distributed and scalable data structures on top of a Redis server.
• requery - (https://github.com/requery/requery) - Modern, lightweight but powerful object mapping and SQL generator. Easily map to or create databases, or perform queries and updates from any Java-using platform.
• Speedment - (https://github.com/speedment/speedment) - Database access library that utilizes Java 8's Stream API for querying.
• Vibur DBCP - (https://www.vibur.org) - JDBC connection pool library with advanced performance monitoring capabilities.
• Xodus - (https://github.com/JetBrains/xodus) - Highly concurrent transactional schema-less and ACID-compliant embedded database.

Java Date and Time - Java Libraries related to handling date and time

• Almanac Converter - (https://github.com/chrisengelsma/almanac-converter) - Simple conversion between different calendar systems.
• iCal4j - (https://github.com/ical4j/ical4j) - Parse and build iCalendar [RFC 5545]] - (https://tools.ietf.org/html/rfc5545) data models.
• Jollyday - (https://github.com/svendiedrichsen/jollyday) - Determines the holidays for a given year, country/name and eventually state/region.
• ThreeTen-Extra - (https://github.com/ThreeTen/threeten-extra) - Additional date-time classes that complement those in JDK 8.
• Time4J - (https://github.com/MenoData/Time4J) - Advanced date and time library. (LGPL-2.1-only)

Java Dependency Injection - Java Libraries that help to realize the Inversion of Control paradigm - (https://en.wikipedia.org/wiki/Inversion_of_control)

• Apache DeltaSpike - (https://deltaspike.apache.org) - CDI extension framework.
• Dagger - (https://dagger.dev) - Compile-time injection framework without reflection.
• Feather - (https://github.com/zsoltherpai/feather) - Ultra-lightweight, JSR-330-compliant dependency injection library.
• Governator - (https://github.com/Netflix/governator) - Extensions and utilities that enhance Google Guice.
• Guice - (https://github.com/google/guice) - Lightweight and opinionated framework that completes Dagger.
• HK2 - (https://javaee.github.io/hk2) - Lightweight and dynamic dependency injection framework.
• JayWire - (https://github.com/vanillasource/jaywire) - Lightweight dependency injection framework. (LGPL-3.0-only)

Java Development - Java Augmentation of the development process at a fundamental level

• AspectJ - (https://www.eclipse.org/aspectj) - Seamless aspect-oriented programming extension.
• DCEVM - (https://dcevm.github.io) - JVM modification that allows unlimited redefinition of loaded classes at runtime. (GPL-2.0-only)
• Faux Pas - (https://github.com/zalando/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.
• HotswapAgent - (https://github.com/HotswapProjects/HotswapAgent) - Unlimited runtime class and resource redefinition. (GPL-2.0-only)
• JavaParser - (https://github.com/javaparser/javaparser) - Parse, modify and generate Java code.
• JavaSymbolSolver - (https://github.com/javaparser/javasymbolsolver) - Symbol solver.
• Manifold - (https://github.com/manifold-systems/manifold) - Re-energizes Java with powerful features like type-safe metaprogramming, structural typing and extension methods.
• NoException - (https://noexception.machinezoo.com) - Allows checked exceptions in functional interfaces and converts exceptions to Optional return.
• SneakyThrow - (https://github.com/rainerhahnekamp/sneakythrow) - Ignores checked exceptions without bytecode manipulation. Can also be used inside Java 8 stream operations.
• Tail - (https://kag0.github.io/tail) - Enable infinite recursion using tail call optimization.

Java Distributed Applications - Java Libraries and frameworks for writing distributed and fault-tolerant applications

• Apache Geode - (https://geode.apache.org) - In-memory data management system that provides reliable asynchronous event notifications and guaranteed message delivery.
• Apache Storm - (https://storm.apache.org) - Realtime computation system.
• Apache ZooKeeper - (https://zookeeper.apache.org) - Coordination service with distributed configuration, synchronization, and naming registry for large distributed systems.
• Atomix - (https://atomix.io) - Fault-tolerant distributed coordination framework.
• Axon - (https://axoniq.io) - Framework for creating CQRS applications.
• Dropwizard Circuit Breaker - (https://github.com/mtakaki/dropwizard-circuitbreaker) - Circuit breaker design pattern for Dropwizard. (GPL-2.0-only)
• Failsafe - (https://github.com/jhalterman/failsafe) - Simple failure handling with retries and circuit breakers.
• Hazelcast - (https://github.com/hazelcast/hazelcast) - Highly scalable in-memory datagrid with a free open-source version.
• JGroups - (http://www.jgroups.org) - Toolkit for reliable messaging and cluster creation.
• Quasar - (http://docs.paralleluniverse.co/quasar) - Lightweight threads and actors for the JVM.
• resilience4j - (https://github.com/resilience4j/resilience4j) - Functional fault tolerance library.
• ScaleCube Services - (https://github.com/scalecube/scalecube-services) - Embeddable Cluster-Membership library based on SWIM and gossip protocol.
• Zuul - (https://github.com/Netflix/zuul) - Gateway service that provides dynamic routing, monitoring, resiliency, security, and more.

Java Distributed Transactions - Java Distributed transactions provide a mechanism for ensuring consistency of data updates in the presence of concurrent access and partial failures

• Atomikos - (https://www.atomikos.com) - Provides transactions for REST, SOA and microservices with support for JTA and XA.
• Bitronix - (https://github.com/bitronix/btm) - Simple but complete implementation of the JTA 1.1 API.
• Narayana - (https://narayana.io) - Provides support for traditional ACID and compensation transactions, also complies with JTA, JTS and other standards. (LGPL-2.1-only)
• Seata - (https://github.com/seata/seata) - Delivers high performance and easy to use distributed transaction services under a microservices architecture.

Java Distribution - Java Tools that handle the distribution of applications in native formats

• Artipie - (https://github.com/artipie/artipie) - Binary artifact management toolkit which hosts them on the file system or S3.
• Boxfuse - (https://boxfuse.com) - Deployment of JVM applications to AWS using the principles of immutable infrastructure.
• Capsule - (https://github.com/puniverse/capsule) - Simple and powerful packaging and deployment. A fat JAR on steroids, or a “Docker for Java” that supports JVM-optimized containers.
• Central Repository - (https://search.maven.org) - Largest binary component repository available as a free service to the open-source community. Default used by Apache Maven, and available in all other build tools.
• Cloudsmith - (https://cloudsmith.io) - Fully managed package management SaaS with support for Maven/Gradle/SBT with a free tier.
• Getdown - (https://github.com/threerings/getdown) - A system for deploying Java applications to end-user computers and keeping them up to date. Developed as an alternative to Java Web Start.
• IzPack - (http://izpack.org) - Setup authoring tool for cross-platform deployments.
• JavaPackager - (https://github.com/fvarrui/JavaPackager) - Maven and Gradle plugin which provides an easy way to package Java applications in native Windows, Mac OS X or GNU/Linux executables, and generate installers for them.
• jlink.online - (https://github.com/cilki/jlink.online) - Builds optimized runtimes over HTTP.
• Nexus - (https://www.sonatype.com) - Binary management with proxy and caching capabilities.
• packr - (https://github.com/libgdx/packr) - Packs JARs, assets and the JVM for native distribution on Windows, Linux and macOS.
• really-executable-jars-maven-plugin - (https://github.com/brianm/really-executable-jars-maven-plugin) - Maven plugin for making self-executing JARs.

Java Document Processing - Java Libraries that assist with processing office document formats

• Apache POI - (https://poi.apache.org) - Supports OOXML (XLSX, DOCX, PPTX) as well as OLE2 (XLS, DOC or PPT).
• documents4j - (https://documents4j.com/#) - API for document format conversion using third-party converters such as MS Word.
• docx4j - Create and manipulate Microsoft Open XML files
• fastexcel - (https://github.com/dhatim/fastexcel) - High performance library to read and write large Excel (XLSX) worksheets.
• zerocell - (https://github.com/creditdatamw/zerocell) - Annotation-based API for reading data from Excel sheets into POJOs with focus on reduced overhead.

Java Financial - Java Libraries related to the financial domain

• Cassandre - (https://github.com/cassandre-tech/cassandre-trading-bot) - Trading bot framework.
• Parity - (https://github.com/paritytrading/parity) - Platform for trading venues.
• Philadelphia - (https://github.com/paritytrading/philadelphia) - Low-latency financial information exchange.
• Square - (https://github.com/square/connect-java-sdk) - Integration with the Square API.
• Stripe - (https://github.com/stripe/stripe-java) - Integration with the Stripe API.
• ta4j - (https://github.com/ta4j/ta4j) - Library for technical analysis.

Java Formal Verification - Java Formal-methods tools - proof assistants, model checking, symbolic execution, etc

• CATG - (https://github.com/ksen007/janala2) - Concolic unit testing engine. Automatically generates unit tests using formal methods.
• Checker Framework - (https://checkerframework.org) - Pluggable type systems. Includes nullness types, physical units, immutability types and more. (GPL-2.0-only WITH Classpath-exception-2.0)
• Daikon - (https://plse.cs.washington.edu/daikon) - Detects likely program invariants and generates JML specs based on those invariants.
• Java Path Finder (JPF) - (https://github.com/javapathfinder/jpf-core) - JVM formal verification tool containing a model checker and more. Created by NASA.
• JMLOK 2.0 - (https://massoni.computacao.ufcg.edu.br/home/jmlok) - Detects inconsistencies between code and JML specification through feedback-directed random tests generation, and suggests a likely cause for each nonconformance detected. (GPL-3.0-only)
• KeY - (https://www.key-project.org) - Formal software development tool that aims to integrate design, implementation, formal specification, and formal verification of object-oriented software as seamlessly as possible. Uses JML for specification and symbolic execution for verification. (GPL-2.0-or-later)
• OpenJML - (http://www.openjml.org) - Translates JML specifications into SMT-LIB format and passes the proof problems implied by the program to backend solvers. (GPL-2.0-only)