language/guarded-patterns: |-

☕ Guarded patterns with when

Add conditions to pattern cases using when guards.

Nested if → when Clause (JDK 21+)

🔗 https://javaevolved.github.io/language/guarded-patterns.html

#Java #JavaEvolved

datetime/math-clamp: |-

☕ Math.clamp()

Clamp a value between bounds with a single clear call.

Nested min/max → Math.clamp() (JDK 21+)

🔗 https://javaevolved.github.io/datetime/math-clamp.html

#Java #JavaEvolved

streams/optional-ifpresentorelse: |-

☕ Optional.ifPresentOrElse()

Handle both present and empty cases of Optional in one call.

if/else on Optional → ifPresentOrElse() (JDK 9+)

🔗 https://javaevolved.github.io/streams/optional-ifpresentorelse.html

#Java #JavaEvolved

strings/string-repeat: |-

☕ String.repeat()

Repeat a string n times without a loop.

StringBuilder Loop → repeat() (JDK 11+)

🔗 https://javaevolved.github.io/strings/string-repeat.html

#Java #JavaEvolved

language/unnamed-variables: |-

☕ Unnamed variables with _

Use _ to signal intent when a variable is intentionally unused.

Unused Variable → _ Placeholder (JDK 22+)

🔗 https://javaevolved.github.io/language/unnamed-variables.html

#Java #JavaEvolved

security/strong-random: |-

☕ Strong random generation

Get the platform's strongest SecureRandom implementation.

new SecureRandom() → getInstanceStrong() (JDK 9+)

🔗 https://javaevolved.github.io/security/strong-random.html

#Java #JavaEvolved

io/writing-files: |-

☕ Writing files

Write a String to a file with one line.

FileWriter + BufferedWriter → Files.writeString() (JDK 11+)

🔗 https://javaevolved.github.io/io/writing-files.html

#Java #JavaEvolved

language/pattern-matching-instanceof: |-

☕ Pattern matching for instanceof

Combine type check and cast in one step with pattern matching.

instanceof + Cast → Pattern Variable (JDK 16+)

🔗 https://javaevolved.github.io/language/pattern-matching-instanceof.html

#Java #JavaEvolved

language/static-methods-in-interfaces: |-

☕ Static methods in interfaces

Add static utility methods directly to interfaces instead of separate utility classes.

Utility classes → Interface static methods (JDK 8+)

🔗 https://javaevolved.github.io/language/static-methods-in-interfaces.html

#Java #JavaEvolved

language/module-import-declarations: |-

☕ Module import declarations

Import all exported packages of a module with a single declaration.

Many Imports → import module (JDK 25+)

🔗 https://javaevolved.github.io/language/module-import-declarations.html

#Java #JavaEvolved

strings/string-strip: |-

☕ String.strip() vs trim()

Use Unicode-aware stripping with strip(), stripLeading(), stripTrailing().

trim() → strip() (JDK 11+)

🔗 https://javaevolved.github.io/strings/string-strip.html

#Java #JavaEvolved

tooling/multi-file-source: |-

☕ Multi-file source launcher

Launch multi-file programs without an explicit compile step.

Compile All First → Source Launcher (JDK 22+)

🔗 https://javaevolved.github.io/tooling/multi-file-source.html

#Java #JavaEvolved

datetime/hex-format: |-

☕ HexFormat

Convert between hex strings and byte arrays with HexFormat.

Manual Hex Conversion → HexFormat (JDK 17+)

🔗 https://javaevolved.github.io/datetime/hex-format.html

#Java #JavaEvolved

language/sealed-classes: |-

☕ Sealed classes for type hierarchies

Restrict which classes can extend a type — enabling exhaustive switches.

Open Hierarchy → sealed permits (JDK 17+)

🔗 https://javaevolved.github.io/language/sealed-classes.html

#Java #JavaEvolved

strings/string-isblank: |-

☕ String.isBlank()

Check for blank strings with a single method call.

trim().isEmpty() → isBlank() (JDK 11+)

🔗 https://javaevolved.github.io/strings/string-isblank.html

#Java #JavaEvolved

enterprise/servlet-vs-jaxrs: |-

☕ Servlet versus JAX-RS

Replace verbose HttpServlet boilerplate with declarative JAX-RS resource classes.

HttpServlet → JAX-RS Resource (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/servlet-vs-jaxrs.html

#Java #JavaEvolved

enterprise/jdbc-vs-jooq: |-

☕ JDBC versus jOOQ

Replace raw JDBC string-based SQL with jOOQ's type-safe, fluent SQL DSL.

Raw JDBC → jOOQ SQL DSL (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/jdbc-vs-jooq.html

#Java #JavaEvolved

collections/reverse-list-iteration: |-

☕ Reverse list iteration

Iterate over a list in reverse order with a clean for-each loop.

Manual ListIterator → reversed() (JDK 21+)

🔗 https://javaevolved.github.io/collections/reverse-list-iteration.html

#Java #JavaEvolved

enterprise/jpa-vs-jakarta-data: |-

☕ JPA versus Jakarta Data

Declare a repository interface and let Jakarta Data generate the DAO implementation automatically.

JPA EntityManager → Jakarta Data Repository (JDK 21+)

🔗 https://javaevolved.github.io/enterprise/jpa-vs-jakarta-data.html

#Java #JavaEvolved

tooling/jfr-profiling: |-

☕ JFR for profiling

Profile any Java app with the built-in Flight Recorder — no external tools.

External Profiler → Java Flight Recorder (JDK 9+)

🔗 https://javaevolved.github.io/tooling/jfr-profiling.html

#Java #JavaEvolved

concurrency/stable-values: |-

☕ Stable values

Thread-safe lazy initialization without volatile or synchronized.

Double-Checked Locking → StableValue (JDK 25+)

🔗 https://javaevolved.github.io/concurrency/stable-values.html

#Java #JavaEvolved

enterprise/jdbc-resultset-vs-jpa-criteria: |-

☕ JDBC ResultSet Mapping vs JPA Criteria API

Replace manual JDBC ResultSet mapping with JPA's type-safe Criteria API for dynamic que…

JDBC ResultSet → JPA Criteria API (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/jdbc-resultset-vs-jpa-criteria.html

#Java #JavaEvolved

language/type-inference-with-var: |-

☕ Type inference with var

Use var for local variable type inference — less noise, same safety.

Explicit Types → var keyword (JDK 10+)

🔗 https://javaevolved.github.io/language/type-inference-with-var.html

#Java #JavaEvolved

streams/predicate-not: |-

☕ Predicate.not() for negation

Use Predicate.not() to negate method references cleanly instead of writing lambda wrappers.

Lambda negation → Predicate.not() (JDK 11+)

🔗 https://javaevolved.github.io/streams/predicate-not.html

#Java #JavaEvolved

concurrency/process-api: |-

☕ Modern Process API

Inspect and manage OS processes with ProcessHandle.

Runtime.exec() → ProcessHandle (JDK 9+)

🔗 https://javaevolved.github.io/concurrency/process-api.html

#Java #JavaEvolved

datetime/java-time-basics: |-

☕ java.time API basics

Use immutable, clear date/time types instead of Date and Calendar.

Date + Calendar → java.time.* (JDK 8+)

🔗 https://javaevolved.github.io/datetime/java-time-basics.html

#Java #JavaEvolved

language/pattern-matching-switch: |-

☕ Pattern matching in switch

Replace if-else instanceof chains with clean switch type patterns.

if-else Chain → Type Patterns (JDK 21+)

🔗 https://javaevolved.github.io/language/pattern-matching-switch.html

#Java #JavaEvolved

language/static-members-in-inner-classes: |-

☕ Static members in inner classes

Define static members in inner classes without requiring static nested…

Must use static nested class → Static members in inner classes (JDK 16+)

🔗 https://javaevolved.github.io/language/static-members-in-inner-classes.html

#Java #JavaEvolved

language/record-patterns: |-

☕ Record patterns (destructuring)

Destructure records directly in patterns — extract fields in one step.

Manual Access → Destructuring (JDK 21+)

🔗 https://javaevolved.github.io/language/record-patterns.html

#Java #JavaEvolved

errors/helpful-npe: |-

☕ Helpful NullPointerExceptions

JVM automatically tells you exactly which variable was null.

Cryptic NPE → Detailed NPE (JDK 14+)

🔗 https://javaevolved.github.io/errors/helpful-npe.html

#Java #JavaEvolved

enterprise/spring-null-safety-jspecify: |-

☕ Spring Null Safety with JSpecify

Spring 7 adopts JSpecify annotations, making non-null the default and reducing annota…

Spring @NonNull/@Nullable → JSpecify @NullMarked (JDK 17+)

🔗 https://javaevolved.github.io/enterprise/spring-null-safety-jspecify.html

#Java #JavaEvolved

concurrency/executor-try-with-resources: |-

☕ ExecutorService auto-close

Use try-with-resources for automatic executor shutdown.

Manual Shutdown → try-with-resources (JDK 19+)

🔗 https://javaevolved.github.io/concurrency/executor-try-with-resources.html

#Java #JavaEvolved

streams/stream-tolist: |-

☕ Stream.toList()

Terminal toList() replaces the verbose collect(Collectors.toList()).

Collectors.toList() → .toList() (JDK 16+)

🔗 https://javaevolved.github.io/streams/stream-tolist.html

#Java #JavaEvolved

strings/string-lines: |-

☕ String.lines() for line splitting

Use String.lines() to split text into a stream of lines without regex overhead.

split("\\n") → lines() (JDK 11+)

🔗 https://javaevolved.github.io/strings/string-lines.html

#Java #JavaEvolved

collections/map-entry-factory: |-

☕ Map.entry() factory

Create map entries with a clean factory method.

SimpleEntry → Map.entry() (JDK 9+)

🔗 https://javaevolved.github.io/collections/map-entry-factory.html

#Java #JavaEvolved

concurrency/scoped-values: |-

☕ Scoped values

Share data across call stacks safely without ThreadLocal pitfalls.

ThreadLocal → ScopedValue (JDK 25+)

🔗 https://javaevolved.github.io/concurrency/scoped-values.html

#Java #JavaEvolved

language/markdown-javadoc-comments: |-

☕ Markdown in Javadoc comments

Write Javadoc comments in Markdown instead of HTML for better readability.

HTML-based Javadoc → Markdown Javadoc (JDK 23+)

🔗 https://javaevolved.github.io/language/markdown-javadoc-comments.html

#Java #JavaEvolved

concurrency/completablefuture-chaining: |-

☕ CompletableFuture chaining

Chain async operations without blocking, using CompletableFuture.

Blocking Future.get() → CompletableFuture (JDK 8+)

🔗 https://javaevolved.github.io/concurrency/completablefuture-chaining.html

#Java #JavaEvolved

enterprise/spring-api-versioning: |-

☕ Spring Framework 7 API Versioning

Replace duplicated version-prefixed controllers with Spring Framework 7's native API ver…

Manual URL Path Versioning → Native API Versioning (JDK 17+)

🔗 https://javaevolved.github.io/enterprise/spring-api-versioning.html

#Java #JavaEvolved

io/http-client: |-

☕ Modern HTTP client

Use the built-in HttpClient for clean, modern HTTP requests.

HttpURLConnection → HttpClient (JDK 11+)

🔗 https://javaevolved.github.io/io/http-client.html

#Java #JavaEvolved

streams/stream-mapmulti: |-

☕ Stream.mapMulti()

Emit zero or more elements per input without creating intermediate streams.

flatMap + List → mapMulti() (JDK 16+)

🔗 https://javaevolved.github.io/streams/stream-mapmulti.html

#Java #JavaEvolved

strings/string-formatted: |-

☕ String.formatted()

Call formatted() on the template string itself.

String.format() → formatted() (JDK 15+)

🔗 https://javaevolved.github.io/strings/string-formatted.html

#Java #JavaEvolved

datetime/duration-and-period: |-

☕ Duration and Period

Calculate time differences with type-safe Duration and Period.

Millisecond Math → Duration / Period (JDK 8+)

🔗 https://javaevolved.github.io/datetime/duration-and-period.html

#Java #JavaEvolved

errors/optional-orelsethrow: |-

☕ Optional.orElseThrow() without supplier

Use Optional.orElseThrow() as a clearer, intent-revealing alternative to get().

get() or orElseThrow(supplier) → orElseThrow() (JDK 10+)

🔗 https://javaevolved.github.io/errors/optional-orelsethrow.html

#Java #JavaEvolved

io/path-of: |-

☕ Path.of() factory

Use Path.of() — the modern factory method on the Path interface.

Paths.get() → Path.of() (JDK 11+)

🔗 https://javaevolved.github.io/io/path-of.html

#Java #JavaEvolved

collections/unmodifiable-collectors: |-

☕ Unmodifiable collectors

Collect directly to an unmodifiable list with stream.toList().

collectingAndThen → stream.toList() (JDK 16+)

🔗 https://javaevolved.github.io/collections/unmodifiable-collectors.html

#Java #JavaEvolved

enterprise/manual-transaction-vs-declarative: |-

☕ Manual JPA Transaction vs Declarative @Transactional

Replace verbose begin/commit/rollback blocks with a single @Transactiona…

Manual Transaction → @Transactional (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/manual-transaction-vs-declarative.html

#Java #JavaEvolved

security/tls-default: |-

☕ TLS 1.3 by default

TLS 1.3 is enabled by default — no explicit protocol configuration needed.

Manual TLS Config → TLS 1.3 Default (JDK 11+)

🔗 https://javaevolved.github.io/security/tls-default.html

#Java #JavaEvolved

enterprise/jndi-lookup-vs-cdi-injection: |-

☕ JNDI Lookup vs CDI Injection

Replace fragile JNDI string lookups with type-safe CDI injection for container-managed resources.

JNDI Lookup → CDI @Inject (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/jndi-lookup-vs-cdi-injection.html

#Java #JavaEvolved

errors/null-in-switch: |-

☕ Null case in switch

Handle null directly as a switch case — no separate guard needed.

Guard Before Switch → case null (JDK 21+)

🔗 https://javaevolved.github.io/errors/null-in-switch.html

#Java #JavaEvolved

datetime/instant-precision: |-

☕ Instant with nanosecond precision

Get timestamps with microsecond or nanosecond precision.

Milliseconds → Nanoseconds (JDK 9+)

🔗 https://javaevolved.github.io/datetime/instant-precision.html

#Java #JavaEvolved

language/primitive-types-in-patterns: |-

☕ Primitive types in patterns

Pattern matching now works with primitive types, not just objects.

Manual Range Checks → Primitive Patterns (JDK 25+)

🔗 https://javaevolved.github.io/language/primitive-types-in-patterns.html

#Java #JavaEvolved

language/text-blocks-for-multiline-strings: |-

☕ Text blocks for multiline strings

Write multiline strings naturally with triple-quote text blocks.

String Concatenation → Text Blocks (JDK 15+)

🔗 https://javaevolved.github.io/language/text-blocks-for-multiline-strings.html

#Java #JavaEvolved

io/file-memory-mapping: |-

☕ File memory mapping

Map files larger than 2GB with deterministic cleanup using MemorySegment.

MappedByteBuffer → MemorySegment with Arena (JDK 22+)

🔗 https://javaevolved.github.io/io/file-memory-mapping.html

#Java #JavaEvolved

tooling/junit6-with-jspecify: |-

☕ JUnit 6 with JSpecify null safety

JUnit 6 adopts JSpecify @NullMarked, making null contracts explicit across its assertion API.

Unannotated API → @NullMarked API (JDK 17+)

🔗 https://javaevolved.github.io/tooling/junit6-with-jspecify.html

#Java #JavaEvolved

streams/virtual-thread-executor: |-

☕ Virtual thread executor

Use virtual thread executors for unlimited lightweight concurrency.

Fixed Thread Pool → Virtual Thread Executor (JDK 21+)

🔗 https://javaevolved.github.io/streams/virtual-thread-executor.html

#Java #JavaEvolved

language/switch-expressions: |-

☕ Switch expressions

Switch as an expression that returns a value — no break, no fall-through.

Switch Statement → Switch Expression (JDK 14+)

🔗 https://javaevolved.github.io/language/switch-expressions.html

#Java #JavaEvolved

errors/record-based-errors: |-

☕ Record-based error responses

Use records for concise, immutable error response types.

Map or Verbose Class → Error Records (JDK 16+)

🔗 https://javaevolved.github.io/errors/record-based-errors.html

#Java #JavaEvolved

streams/collectors-flatmapping: |-

☕ Collectors.flatMapping()

Use flatMapping() to flatten inside a grouping collector.

Nested flatMap → flatMapping() (JDK 9+)

🔗 https://javaevolved.github.io/streams/collectors-flatmapping.html

#Java #JavaEvolved

language/diamond-operator: |-

☕ Diamond with anonymous classes

Diamond operator now works with anonymous classes too.

Repeat Type Args → Diamond <> (JDK 9+)

🔗 https://javaevolved.github.io/language/diamond-operator.html

#Java #JavaEvolved

language/compact-canonical-constructor: |-

☕ Compact canonical constructor

Validate and normalize record fields without repeating parameter lists.

Explicit constructor validation → Compact constructor (JDK 16+)

🔗 https://javaevolved.github.io/language/compact-canonical-constructor.html

#Java #JavaEvolved

tooling/aot-class-preloading: |-

☕ AOT class preloading

Cache class loading and compilation for instant startup.

Cold Start Every Time → AOT Cache (JDK 25+)

🔗 https://javaevolved.github.io/tooling/aot-class-preloading.html

#Java #JavaEvolved

io/deserialization-filters: |-

☕ Deserialization filters

Restrict which classes can be deserialized to prevent attacks.

Accept Everything → ObjectInputFilter (JDK 9+)

🔗 https://javaevolved.github.io/io/deserialization-filters.html

#Java #JavaEvolved

enterprise/spring-xml-config-vs-annotations: |-

☕ Spring XML Bean Config vs Annotation-Driven

Replace verbose Spring XML bean definitions with concise annotation-dri…

XML Bean Definitions → Annotation-Driven Beans (JDK 17+)

🔗 https://javaevolved.github.io/enterprise/spring-xml-config-vs-annotations.html

#Java #JavaEvolved

security/key-derivation-functions: |-

☕ Key Derivation Functions

Derive cryptographic keys using the standard KDF API.

Manual PBKDF2 → KDF API (JDK 25+)

🔗 https://javaevolved.github.io/security/key-derivation-functions.html

#Java #JavaEvolved

concurrency/virtual-threads: |-

☕ Virtual threads

Create millions of lightweight virtual threads instead of heavy OS threads.

Platform Threads → Virtual Threads (JDK 21+)

🔗 https://javaevolved.github.io/concurrency/virtual-threads.html

#Java #JavaEvolved

collections/immutable-list-creation: |-

☕ Immutable list creation

Create immutable lists in one clean expression.

Verbose Wrapping → List.of() (JDK 9+)

🔗 https://javaevolved.github.io/collections/immutable-list-creation.html

#Java #JavaEvolved

enterprise/jsf-managed-bean-vs-cdi-named: |-

☕ JSF Managed Bean vs CDI Named Bean

Replace deprecated JSF @ManagedBean with CDI @Named for a unified dependency injection model.

@ManagedBean → @Named + CDI (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/jsf-managed-bean-vs-cdi-named.html

#Java #JavaEvolved

errors/multi-catch: |-

☕ Multi-catch exception handling

Catch multiple exception types in a single catch block.

Separate Catch Blocks → Multi-catch (JDK 7+)

🔗 https://javaevolved.github.io/errors/multi-catch.html

#Java #JavaEvolved

io/try-with-resources-effectively-final: |-

☕ Try-with-resources improvement

Use existing effectively-final variables directly in try-with-resources.

Re-declare Variable → Effectively Final (JDK 9+)

🔗 https://javaevolved.github.io/io/try-with-resources-effectively-final.html

#Java #JavaEvolved

concurrency/lock-free-lazy-init: |-

☕ Lock-free lazy initialization

Replace double-checked locking with StableValue for lazy singletons.

synchronized + volatile → StableValue (JDK 25+)

🔗 https://javaevolved.github.io/concurrency/lock-free-lazy-init.html

#Java #JavaEvolved

collections/stream-toarray-typed: |-

☕ Typed stream toArray

Filter a collection and collect the results to a typed array using a single stream expression.

Manual Filter + Copy → toArray(generator) (JDK 8+)

🔗 https://javaevolved.github.io/collections/stream-toarray-typed.html

#Java #JavaEvolved

tooling/jshell-prototyping: |-

☕ JShell for prototyping

Try Java expressions interactively without creating files.

Create File + Compile + Run → jshell REPL (JDK 9+)

🔗 https://javaevolved.github.io/tooling/jshell-prototyping.html

#Java #JavaEvolved

io/inputstream-transferto: |-

☕ InputStream.transferTo()

Copy an InputStream to an OutputStream in one call.

Manual Copy Loop → transferTo() (JDK 9+)

🔗 https://javaevolved.github.io/io/inputstream-transferto.html

#Java #JavaEvolved

collections/sequenced-collections: |-

☕ Sequenced collections

Access first/last elements and reverse views with clean API methods.

Index Arithmetic → getFirst/getLast (JDK 21+)

🔗 https://javaevolved.github.io/collections/sequenced-collections.html

#Java #JavaEvolved

security/random-generator: |-

☕ RandomGenerator interface

Use the RandomGenerator interface to choose random number algorithms by name without coupling t…

new Random() / ThreadLocalRandom → RandomGenerator factory (JDK 17+)

🔗 https://javaevolved.github.io/security/random-generator.html

#Java #JavaEvolved

language/compact-source-files: |-

☕ Compact source files

Write a complete program without class declaration or public static void main.

Main Class Ceremony → void main() (JDK 25+)

🔗 https://javaevolved.github.io/language/compact-source-files.html

#Java #JavaEvolved

collections/immutable-set-creation: |-

☕ Immutable set creation

Create immutable sets with a single factory call.

Verbose Wrapping → Set.of() (JDK 9+)

🔗 https://javaevolved.github.io/collections/immutable-set-creation.html

#Java #JavaEvolved

concurrency/structured-concurrency: |-

☕ Structured concurrency

Manage concurrent task lifetimes as a single unit of work.

Manual Thread Lifecycle → StructuredTaskScope (JDK 25+)

🔗 https://javaevolved.github.io/concurrency/structured-concurrency.html

#Java #JavaEvolved

tooling/built-in-http-server: |-

☕ Built-in HTTP server

Java 18 includes a built-in minimal HTTP server for prototyping and file serving.

External Server / Framework → jwebserver CLI (JDK 18+)

🔗 https://javaevolved.github.io/tooling/built-in-http-server.html

#Java #JavaEvolved

errors/optional-chaining: |-

☕ Optional chaining

Replace nested null checks with an Optional pipeline.

Nested Null Checks → Optional Pipeline (JDK 9+)

🔗 https://javaevolved.github.io/errors/optional-chaining.html

#Java #JavaEvolved

language/flexible-constructor-bodies: |-

☕ Flexible constructor bodies

Validate and compute values before calling super() or this().

Validate After super() → Code Before super() (JDK 25+)

🔗 https://javaevolved.github.io/language/flexible-constructor-bodies.html

#Java #JavaEvolved

io/reading-files: |-

☕ Reading files

Read an entire file into a String with one line.

BufferedReader → Files.readString() (JDK 11+)

🔗 https://javaevolved.github.io/io/reading-files.html

#Java #JavaEvolved

streams/stream-takewhile-dropwhile: |-

☕ Stream takeWhile / dropWhile

Take or drop elements from a stream based on a predicate.

Manual Loop → takeWhile/dropWhile (JDK 9+)

🔗 https://javaevolved.github.io/streams/stream-takewhile-dropwhile.html

#Java #JavaEvolved

streams/stream-of-nullable: |-

☕ Stream.ofNullable()

Create a zero-or-one element stream from a nullable value.

Null Check → ofNullable() (JDK 9+)

🔗 https://javaevolved.github.io/streams/stream-of-nullable.html

#Java #JavaEvolved

collections/copying-collections-immutably: |-

☕ Copying collections immutably

Create an immutable copy of any collection in one call.

Manual Copy + Wrap → List.copyOf() (JDK 10+)

🔗 https://javaevolved.github.io/collections/copying-collections-immutably.html

#Java #JavaEvolved

enterprise/singleton-ejb-vs-cdi-application-scoped: |-

☕ Singleton EJB vs CDI @ApplicationScoped

Replace Singleton EJBs with CDI @ApplicationScoped beans for simpler shared…

@Singleton EJB → @ApplicationScoped CDI (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/singleton-ejb-vs-cdi-application-scoped.html

#Java #JavaEvolved

security/pem-encoding: |-

☕ PEM encoding/decoding

Encode and decode PEM-formatted cryptographic objects natively.

Manual Base64 + Headers → PEM API (JDK 25+)

🔗 https://javaevolved.github.io/security/pem-encoding.html

#Java #JavaEvolved

language/default-interface-methods: |-

☕ Default interface methods

Add method implementations directly in interfaces, enabling multiple inherita…

Abstract classes for shared behavior → Default methods on interfaces (JDK 8+)

🔗 https://javaevolved.github.io/language/default-interface-methods.html

#Java #JavaEvolved

io/io-class-console-io: |-

☕ IO class for console I/O

The new IO class provides simple, concise methods for console input and output.

System.out / Scanner → IO class (JDK 25+)

🔗 https://javaevolved.github.io/io/io-class-console-io.html

#Java #JavaEvolved

language/records-for-data-classes: |-

☕ Records for data classes

One line replaces 30+ lines of boilerplate for immutable data carriers.

Verbose POJO → record (JDK 16+)

🔗 https://javaevolved.github.io/language/records-for-data-classes.html

#Java #JavaEvolved

language/private-interface-methods: |-

☕ Private interface methods

Extract shared logic in interfaces using private methods.

Duplicated Logic → Private Methods (JDK 9+)

🔗 https://javaevolved.github.io/language/private-interface-methods.html

#Java #JavaEvolved

streams/stream-gatherers: |-

☕ Stream gatherers

Use gatherers for custom intermediate stream operations.

Custom Collector → gather() (JDK 24+)

🔗 https://javaevolved.github.io/streams/stream-gatherers.html

#Java #JavaEvolved

strings/string-chars-stream: |-

☕ String chars as stream

Process string characters as a stream pipeline.

Manual Loop → chars() Stream (JDK 9+)

🔗 https://javaevolved.github.io/strings/string-chars-stream.html

#Java #JavaEvolved

enterprise/soap-vs-jakarta-rest: |-

☕ SOAP Web Services vs Jakarta REST

Replace heavyweight SOAP/WSDL endpoints with clean Jakarta REST resources returning JSON.

JAX-WS / SOAP → Jakarta REST / JSON (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/soap-vs-jakarta-rest.html

#Java #JavaEvolved

enterprise/ejb-timer-vs-jakarta-scheduler: |-

☕ EJB Timer vs Jakarta Scheduler

Replace heavyweight EJB timers with Jakarta Concurrency's ManagedScheduledExecutor…

EJB TimerService → ManagedScheduledExecutorService (JDK 11+)

🔗 https://javaevolved.github.io/enterprise/ejb-timer-vs-jakarta-scheduler.html

#Java #JavaEvolved

concurrency/concurrent-http-virtual: |-

☕ Concurrent HTTP with virtual threads

Fetch many URLs concurrently with virtual threads and HttpClient.

Thread Pool + URLConnection → Virtual Threads + HttpClient (JDK 21+)

🔗 https://javaevolved.github.io/concurrency/concurrent-http-virtual.html

#Java #JavaEvolved

io/files-mismatch: |-

☕ Files.mismatch()

Compare two files efficiently without loading them into memory.

Manual Byte Compare → Files.mismatch() (JDK 12+)

🔗 https://javaevolved.github.io/io/files-mismatch.html

#Java #JavaEvolved

collections/immutable-map-creation: |-

☕ Immutable map creation

Create immutable maps inline without a builder.

Map Builder Pattern → Map.of() (JDK 9+)

🔗 https://javaevolved.github.io/collections/immutable-map-creation.html

#Java #JavaEvolved

tooling/single-file-execution: |-

☕ Single-file execution

Run single-file Java programs directly without javac.

Two-Step Compile → Direct Launch (JDK 11+)

🔗 https://javaevolved.github.io/tooling/single-file-execution.html

#Java #JavaEvolved