Java Master Cheat-Sheets - Master Edition

package com.seb4u.demo.orders;          // Core / Domain / Service ohne Framework
package com.seb4u.demo.io;              // I/O, NIO, Dateien
package com.seb4u.demo.concurrent;      // Virtual Threads, Locks, Queues
package com.seb4u.demo.spring.orders;   // Spring MVC / Spring Boot Adapter
package com.seb4u.demo.jakarta.orders;  // Jakarta Servlet / JPA Adapter

package com.seb4u.demo.core;

import java.math.BigDecimal;
import java.util.Currency;
import java.util.Objects;

public record Money(BigDecimal amount, Currency currency) {
    public Money {
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(currency, "currency");
        if (amount.scale() > currency.getDefaultFractionDigits()) {
            throw new IllegalArgumentException("Too many fraction digits for " + currency);
        }
    }

    public Money add(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch");
        }
        return new Money(amount.add(other.amount), currency);
    }
}

package com.seb4u.demo.core;

import java.time.Instant;
import java.util.UUID;

public sealed interface OrderEvent permits OrderPlaced, OrderPaid, OrderCancelled {
    UUID orderId();
    Instant occurredAt();
}

public record OrderPlaced(UUID orderId, Instant occurredAt, String customerId) implements OrderEvent {}
public record OrderPaid(UUID orderId, Instant occurredAt, String paymentRef) implements OrderEvent {}
public record OrderCancelled(UUID orderId, Instant occurredAt, String reason) implements OrderEvent {}

final class EventText {
    static String describe(OrderEvent event) {
        return switch (event) {
            case OrderPlaced e -> "Order placed for " + e.customerId();
            case OrderPaid e -> "Payment received: " + e.paymentRef();
            case OrderCancelled e -> "Cancelled: " + e.reason();
        };
    }
}

package com.seb4u.demo.collections;

import java.util.UUID;

public record OrderId(UUID value) {
    public OrderId {
        if (value == null) throw new IllegalArgumentException("OrderId required");
    }
    public static OrderId newId() { return new OrderId(UUID.randomUUID()); }
}

public record CustomerId(String value) {
    public CustomerId {
        if (value == null || value.isBlank()) throw new IllegalArgumentException("CustomerId required");
    }
}

final class OrderService {
    void assign(OrderId orderId, CustomerId customerId) {
        // assign(customerId, orderId) kompiliert nicht mehr versehentlich.
    }
}

package com.seb4u.demo.collections;

import java.util.*;
import java.util.stream.Collectors;

public record Invoice(String customerId, String number, long cents) {}

public final class InvoiceIndex {
    public static Map<String, List<Invoice>> byCustomer(List<Invoice> invoices) {
        return invoices.stream().collect(Collectors.groupingBy(
            Invoice::customerId,
            LinkedHashMap::new,
            Collectors.collectingAndThen(Collectors.toList(), List::copyOf)
        ));
    }
}

package com.seb4u.demo.streams;

import java.util.*;
import java.util.stream.Collectors;

public record Sale(String region, String product, long cents) {}
public record RegionRevenue(String region, long totalCents, int count) {}

public final class RevenueReport {
    public static List<RegionRevenue> summarize(List<Sale> sales) {
        return sales.stream()
            .filter(s -> s.cents() > 0)
            .collect(Collectors.groupingBy(Sale::region, Collectors.toList()))
            .entrySet().stream()
            .map(e -> new RegionRevenue(
                e.getKey(),
                e.getValue().stream().mapToLong(Sale::cents).sum(),
                e.getValue().size()))
            .sorted(Comparator.comparingLong(RegionRevenue::totalCents).reversed())
            .toList();
    }
}

package com.seb4u.demo.streams;

import java.util.*;

public record User(String id, String email, boolean active) {}

public final class UserDirectory {
    private final Map<String, User> usersByEmail;

    public UserDirectory(List<User> users) {
        this.usersByEmail = users.stream().collect(
            java.util.stream.Collectors.toUnmodifiableMap(User::email, u -> u));
    }

    public Optional<User> findActiveByEmail(String email) {
        return Optional.ofNullable(usersByEmail.get(email))
            .filter(User::active);
    }
}

package com.seb4u.demo.errors;

import java.util.List;

public sealed interface Result<T> permits Result.Ok, Result.Invalid, Result.Failed {
    record Ok<T>(T value) implements Result<T> {}
    record Invalid<T>(List<String> violations) implements Result<T> {}
    record Failed<T>(String code, Throwable cause) implements Result<T> {}

    static <T> Result<T> ok(T value) { return new Ok<>(value); }
    static <T> Result<T> invalid(List<String> violations) { return new Invalid<>(List.copyOf(violations)); }
    static <T> Result<T> failed(String code, Throwable cause) { return new Failed<>(code, cause); }
}

package com.seb4u.demo.errors;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public final class ConfigLoader {
    public String load(Path path) {
        try {
            return Files.readString(path);
        } catch (IOException ex) {
            throw new IllegalStateException("Cannot read config: " + path.toAbsolutePath(), ex);
        }
    }
}

package com.seb4u.demo.io;

import java.nio.file.Path;

public final class SafePathResolver {
    private final Path root;

    public SafePathResolver(Path root) {
        this.root = root.toAbsolutePath().normalize();
    }

    public Path resolveUserPath(String input) {
        Path candidate = root.resolve(input).normalize().toAbsolutePath();
        if (!candidate.startsWith(root)) {
            throw new SecurityException("Path traversal blocked: " + input);
        }
        return candidate;
    }
}

package com.seb4u.demo.io;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;

import static java.nio.file.StandardCopyOption.*;

public final class AtomicTextWriter {
    public void write(Path target, String content) throws IOException {
        Path dir = target.toAbsolutePath().getParent();
        Files.createDirectories(dir);
        Path tmp = Files.createTempFile(dir, target.getFileName().toString(), ".tmp");
        try {
            Files.writeString(tmp, content, StandardCharsets.UTF_8,
                StandardOpenOption.TRUNCATE_EXISTING);
            Files.move(tmp, target, ATOMIC_MOVE, REPLACE_EXISTING);
        } finally {
            Files.deleteIfExists(tmp);
        }
    }
}

package com.seb4u.demo.io;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.concurrent.atomic.LongAdder;

public final class CsvCounter {
    public long countValidRows(Path csv) throws IOException {
        LongAdder count = new LongAdder();
        try (var lines = Files.lines(csv, StandardCharsets.UTF_8)) {
            lines.skip(1)
                .filter(line -> !line.isBlank())
                .filter(line -> line.split(",", -1).length >= 4)
                .forEach(line -> count.increment());
        }
        return count.sum();
    }
}

package com.seb4u.demo.time;

import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;

public final class TokenExpiry {
    private final Clock clock;

    public TokenExpiry(Clock clock) {
        this.clock = clock;
    }

    public boolean expired(Instant expiresAt) {
        return !Instant.now(clock).isBefore(expiresAt);
    }

    public static TokenExpiry fixedForTest() {
        return new TokenExpiry(Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneOffset.UTC));
    }
}

package com.seb4u.demo.time;

import java.text.NumberFormat;
import java.util.Currency;
import java.util.Locale;

public final class MoneyFormatter {
    public String format(long cents, Currency currency, Locale locale) {
        NumberFormat format = NumberFormat.getCurrencyInstance(locale);
        format.setCurrency(currency);
        return format.format(cents / 100.0);
    }
}

package com.seb4u.demo.concurrent;

import java.util.List;
import java.util.concurrent.*;
import java.util.function.Function;

public final class BulkheadRunner<T, R> implements AutoCloseable {
    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
    private final Semaphore permits;

    public BulkheadRunner(int maxConcurrent) {
        this.permits = new Semaphore(maxConcurrent);
    }

    public List<R> runAll(List<T> items, Function<T, R> task) throws InterruptedException {
        List<Future<R>> futures = items.stream()
            .map(item -> executor.submit(() -> {
                permits.acquire();
                try { return task.apply(item); }
                finally { permits.release(); }
            }))
            .toList();

        return futures.stream().map(f -> {
            try { return f.get(10, TimeUnit.SECONDS); }
            catch (Exception e) { throw new CompletionException(e); }
        }).toList();
    }

    @Override public void close() { executor.close(); }
}

package com.seb4u.demo.concurrent;

import java.util.concurrent.*;

public final class ImportQueue implements AutoCloseable {
    private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(500);
    private final ExecutorService worker = Executors.newSingleThreadExecutor();
    private volatile boolean running = true;

    public void start() {
        worker.submit(() -> {
            while (running || !queue.isEmpty()) {
                String item = queue.poll(250, TimeUnit.MILLISECONDS);
                if (item != null) process(item);
            }
            return null;
        });
    }

    public boolean submit(String item) throws InterruptedException {
        return queue.offer(item, 2, TimeUnit.SECONDS);
    }

    private void process(String item) { /* persistieren, validieren, publizieren */ }

    @Override public void close() {
        running = false;
        worker.close();
    }
}

package com.seb4u.demo.async;

import java.time.Duration;
import java.util.concurrent.*;

public final class PricingGateway {
    private final Executor executor;

    public PricingGateway(Executor executor) {
        this.executor = executor;
    }

    public CompletableFuture<Long> priceCents(String sku) {
        return CompletableFuture.supplyAsync(() -> callRemotePricing(sku), executor)
            .orTimeout(800, TimeUnit.MILLISECONDS)
            .exceptionally(ex -> fallbackPrice(sku));
    }

    private long callRemotePricing(String sku) { return 1299L; }
    private long fallbackPrice(String sku) { return 999L; }
}

package com.seb4u.demo.async;

import java.util.List;
import java.util.concurrent.*;
import java.util.function.Supplier;

public record Try<T>(T value, Throwable error) {
    static <T> Try<T> ok(T value) { return new Try<>(value, null); }
    static <T> Try<T> failed(Throwable error) { return new Try<>(null, error); }
}

public final class BatchAsync {
    public static <T> List<Try<T>> run(List<Supplier<T>> tasks, Executor executor) {
        var futures = tasks.stream()
            .map(task -> CompletableFuture.supplyAsync(task, executor)
                .<Try<T>>thenApply(Try::ok)
                .exceptionally(Try::failed))
            .toList();
        return futures.stream().map(CompletableFuture::join).toList();
    }
}

<modules>
  <module>commerceflow-domain</module>
  <module>commerceflow-application</module>
  <module>commerceflow-adapter-file</module>
  <module>commerceflow-adapter-spring</module>
  <module>commerceflow-tests</module>
</modules>

<properties>
  <maven.compiler.release>25</maven.compiler.release>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<build>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <release>${maven.compiler.release}</release>
        </configuration>
      </plugin>
    </plugins>
  </pluginManagement>
</build>

package com.seb4u.demo.testing;

import org.junit.jupiter.api.Test;
import java.time.*;
import static org.junit.jupiter.api.Assertions.*;

final class TokenExpiryTest {
    @Test
    void token_is_expired_after_expiry_instant() {
        Clock clock = Clock.fixed(Instant.parse("2026-01-01T10:00:00Z"), ZoneOffset.UTC);
        TokenExpiry expiry = new TokenExpiry(clock);

        assertTrue(expiry.expired(Instant.parse("2026-01-01T09:59:59Z")));
        assertFalse(expiry.expired(Instant.parse("2026-01-01T10:00:01Z")));
    }
}

package com.seb4u.demo.testing;

import java.util.UUID;

public final class OrderBuilder {
    private UUID id = UUID.randomUUID();
    private String customerId = "C-100";

    public OrderBuilder customer(String customerId) {
        this.customerId = customerId;
        return this;
    }

    public TestOrder build() {
        return new TestOrder(id, customerId);
    }
}

record TestOrder(UUID id, String customerId) {}

package com.seb4u.demo.commerce.application;

import com.seb4u.demo.commerce.domain.*;

public final class PlaceOrderUseCase {
    private final OrderRepository orders;
    private final EventPublisher events;

    public PlaceOrderUseCase(OrderRepository orders, EventPublisher events) {
        this.orders = orders;
        this.events = events;
    }

    public OrderId handle(PlaceOrderCommand command) {
        Order order = Order.place(command.customerId(), command.items());
        orders.save(order);
        events.publish(order.pullEvents());
        return order.id();
    }
}

package com.seb4u.demo.commerce.application;

import com.seb4u.demo.commerce.domain.*;
import java.util.List;
import java.util.Optional;

public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId id);
}

public interface EventPublisher {
    void publish(List<OrderEvent> events);
}

package com.seb4u.demo.spring.orders;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final PlaceOrderService service;

    public OrderController(PlaceOrderService service) {
        this.service = service;
    }

    @PostMapping
    ResponseEntity<OrderResponse> place(@Valid @RequestBody PlaceOrderRequest request) {
        String id = service.place(request.customerId());
        return ResponseEntity.accepted().body(new OrderResponse(id));
    }

    public record PlaceOrderRequest(@NotBlank String customerId) {}
    public record OrderResponse(String orderId) {}
}

package com.seb4u.demo.spring.errors;

import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;

@RestControllerAdvice
public class ApiExceptionHandler {
    @ExceptionHandler(IllegalArgumentException.class)
    ProblemDetail badRequest(IllegalArgumentException ex) {
        ProblemDetail problem = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        problem.setTitle("Invalid request");
        problem.setDetail(ex.getMessage());
        problem.setProperty("code", "REQUEST_INVALID");
        return problem;
    }
}

package com.seb4u.demo.jakarta.orders;

import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.*;
import java.io.IOException;

@WebServlet("/orders")
public class OrderServlet extends HttpServlet {
    private final PlaceOrderUseCase useCase = new PlaceOrderUseCase();

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        String customerId = req.getParameter("customerId");
        String orderId = useCase.place(customerId);
        resp.setStatus(HttpServletResponse.SC_ACCEPTED);
        resp.setContentType("application/json");
        resp.getWriter().write("{"orderId":"" + orderId + ""}");
    }
}

package com.seb4u.demo.jakarta.persistence;

import jakarta.persistence.*;

@Entity
@Table(name = "orders")
public class OrderEntity {
    @Id
    private String id;
    private String customerId;
    private String status;

    protected OrderEntity() {}

    public OrderEntity(String id, String customerId, String status) {
        this.id = id;
        this.customerId = customerId;
        this.status = status;
    }
}

package com.seb4u.demo.persistence;

import javax.sql.DataSource;
import java.sql.*;

public final class JdbcOrderRepository {
    private final DataSource dataSource;

    public JdbcOrderRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void insert(String id, String customerId) throws SQLException {
        String sql = "insert into orders(id, customer_id, status) values (?, ?, ?)";
        try (Connection con = dataSource.getConnection()) {
            boolean oldAutoCommit = con.getAutoCommit();
            con.setAutoCommit(false);
            try (PreparedStatement ps = con.prepareStatement(sql)) {
                ps.setString(1, id);
                ps.setString(2, customerId);
                ps.setString(3, "PLACED");
                ps.executeUpdate();
                con.commit();
            } catch (SQLException ex) {
                con.rollback();
                throw ex;
            } finally {
                con.setAutoCommit(oldAutoCommit);
            }
        }
    }
}

package com.seb4u.demo.persistence;

import java.sql.*;
import java.time.Instant;

public final class OutboxWriter {
    public void append(Connection con, String aggregateId, String type, String payload) throws SQLException {
        try (PreparedStatement ps = con.prepareStatement("""
            insert into outbox(id, aggregate_id, event_type, payload, created_at)
            values (?, ?, ?, ?, ?)
            """)) {
            ps.setString(1, java.util.UUID.randomUUID().toString());
            ps.setString(2, aggregateId);
            ps.setString(3, type);
            ps.setString(4, payload);
            ps.setTimestamp(5, Timestamp.from(Instant.now()));
            ps.executeUpdate();
        }
    }
}

package com.seb4u.demo.security;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;

public final class HmacVerifier {
    public boolean valid(String body, String expectedHex, byte[] secret) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret, "HmacSHA256"));
        byte[] actual = mac.doFinal(body.getBytes(StandardCharsets.UTF_8));
        byte[] expected = HexFormat.of().parseHex(expectedHex);
        return MessageDigest.isEqual(actual, expected);
    }
}

package com.seb4u.demo.spring.security;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;

@Service
public class AdminOrderService {
    @PreAuthorize("hasAuthority('ORDER_CANCEL')")
    public void cancelOrder(String orderId, String reason) {
        // Use Case aufrufen, Audit Event schreiben
    }
}

package com.seb4u.demo.observability;

import java.time.Instant;
import java.util.Map;

public final class StructuredLog {
    public static void info(String event, Map<String, ?> fields) {
        System.out.println(Map.of(
            "level", "INFO",
            "event", event,
            "time", Instant.now().toString(),
            "fields", fields
        ));
    }
}

package com.seb4u.demo.performance;

public final class TimerProbe implements AutoCloseable {
    private final String name;
    private final long start = System.nanoTime();

    public TimerProbe(String name) { this.name = name; }

    @Override public void close() {
        long millis = (System.nanoTime() - start) / 1_000_000;
        System.out.println(name + " took " + millis + " ms");
    }
}

package com.seb4u.demo.spring.web;

import java.util.List;

public record PageResponse<T>(
    List<T> items,
    int page,
    int size,
    long totalItems,
    int totalPages
) {
    public PageResponse {
        items = List.copyOf(items);
        if (size <= 0 || size > 100) throw new IllegalArgumentException("Invalid page size");
    }
}

package com.seb4u.demo.spring.web;

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/payments")
public class PaymentController {
    @PostMapping
    String pay(@RequestHeader("Idempotency-Key") String idempotencyKey,
               @RequestBody PaymentRequest request) {
        return "accepted:" + idempotencyKey;
    }

    record PaymentRequest(String orderId, long amountCents) {}
}

package com.seb4u.demo.cloud;

import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public final class IdempotentConsumer {
    private final Set<String> processed = ConcurrentHashMap.newKeySet();

    public void handle(String eventId, Runnable action) {
        if (!processed.add(eventId)) {
            return; // bereits verarbeitet
        }
        action.run();
    }
}

services:
  commerceflow-api:
    build:
      context: .
      dockerfile: Dockerfile.spring
    ports:
      - "8080:8080"
    environment:
      SPRING_PROFILES_ACTIVE: docker
      DB_HOST: postgres
    depends_on:
      - postgres

  postgres:
    image: postgres:16
    environment:
      POSTGRES_DB: commerceflow
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app

package com.seb4u.demo.algorithms;

public final class LongestOnesAfterFlip {
    public int longest(int[] bits, int maxZeros) {
        int left = 0, zeros = 0, best = 0;
        for (int right = 0; right < bits.length; right++) {
            if (bits[right] == 0) zeros++;
            while (zeros > maxZeros) {
                if (bits[left++] == 0) zeros--;
            }
            best = Math.max(best, right - left + 1);
        }
        return best;
    }
}

package com.seb4u.demo.algorithms;

import java.util.*;

public final class Dijkstra {
    record Edge(String to, int weight) {}
    record Node(String id, int distance) {}

    public Map<String, Integer> shortest(Map<String, List<Edge>> graph, String start) {
        Map<String, Integer> dist = new HashMap<>();
        PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(Node::distance));
        dist.put(start, 0);
        pq.add(new Node(start, 0));
        while (!pq.isEmpty()) {
            Node current = pq.poll();
            if (current.distance() != dist.get(current.id())) continue;
            for (Edge edge : graph.getOrDefault(current.id(), List.of())) {
                int next = current.distance() + edge.weight();
                if (next < dist.getOrDefault(edge.to(), Integer.MAX_VALUE)) {
                    dist.put(edge.to(), next);
                    pq.add(new Node(edge.to(), next));
                }
            }
        }
        return dist;
    }
}

Code Review Checklist
- [ ] Package Standard: com.seb4u.demo..., spring oder jakarta korrekt?
- [ ] Fachlogik frei von Frameworks?
- [ ] I/O: try-with-resources, sichere Paths, explizites Encoding?
- [ ] Concurrency: Timeout, Cancellation, Shutdown, Backpressure?
- [ ] API: DTOs, Validation, Fehlercodes, keine Stacktraces?
- [ ] Tests: wichtigste Fachregel + Fehlerfall + Grenze?
- [ ] Observability: Korrelation, strukturierte Logs, keine Secrets?

1. Problemgrenze klären: Input, Output, Constraints, Fehlerfälle.
2. Einfachste korrekte Lösung erklären.
3. Datenstruktur begründen und Big-O nennen.
4. Edge Cases nennen: null/leer/groß/duplikate/concurrency.
5. Testfälle skizzieren.
6. Produktionsaspekte ergänzen: Logging, Timeout, Security, Monitoring.