Explore Java's powerful deconstruction patterns including Records, Pattern Matching, and advanced destructuring techniques.

Table of Contents

1. Record Deconstruction
2. Pattern Matching with instanceof
3. Switch Expression Patterns
4. Custom Deconstruction Patterns
5. Advanced Nesting Patterns
6. Real-World Use Cases

Record Deconstruction

1. Basic Record Deconstruction

// Basic record definition
public record Person(String name, int age, String email) {
// Compact constructor with validation
public Person {
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative");
}
if (email != null && !email.contains("@")) {
throw new IllegalArgumentException("Invalid email format");
}
}
// Static factory method
public static Person of(String name, int age) {
return new Person(name, age, null);
}
}
// Deconstruction examples
public class RecordDeconstruction {
public static void main(String[] args) {
// Create record instance
Person person = new Person("Alice", 30, "[email protected]");
// Traditional accessors
String name = person.name();
int age = person.age();
String email = person.email();
// Deconstruction in Java 16+ (conceptual - not actual syntax)
// This demonstrates the concept that will be available in future versions
System.out.println("Name: " + name + ", Age: " + age + ", Email: " + email);
}
// Method that demonstrates deconstruction concept
public static void processPerson(Person person) {
// Imagine future Java version supporting this:
// Person(String name, int age, String email) = person;
// Current approach - using accessors
String name = person.name();
int age = person.age();
String email = person.email();
System.out.printf("Processing %s (%d years old) - %s%n", name, age, email);
}
}

2. Advanced Record Patterns

// Complex record with nested records
public record Address(String street, String city, String zipCode, String country) {
public Address {
if (street == null || street.isBlank()) {
throw new IllegalArgumentException("Street cannot be empty");
}
}
public String format() {
return String.format("%s, %s %s, %s", street, city, zipCode, country);
}
}
public record Employee(
String id,
Person person,
Address address,
String department,
double salary
) {
public Employee {
if (salary < 0) {
throw new IllegalArgumentException("Salary cannot be negative");
}
}
public boolean isRemote() {
return address.city().equals("REMOTE");
}
}
// Record pattern matching examples
public class AdvancedRecordPatterns {
// Traditional approach to extracting data
public static void printEmployeeInfoTraditional(Employee employee) {
Person person = employee.person();
Address address = employee.address();
String name = person.name();
String city = address.city();
System.out.printf("Employee %s works in %s%n", name, city);
}
// Using method to simulate pattern matching
public static void extractEmployeeData(Employee employee) {
// Simulating what pattern matching might look like
String id = employee.id();
Person person = employee.person();
Address address = employee.address();
String department = employee.department();
double salary = employee.salary();
// Process extracted data
if (salary > 100000) {
System.out.printf("High earner: %s in %s%n", 
person.name(), department);
}
}
// Process multiple records
public static void processEmployees(List<Employee> employees) {
for (Employee emp : employees) {
// Extract nested data
String empName = emp.person().name();
String empCity = emp.address().city();
double empSalary = emp.salary();
System.out.printf("%s in %s earns $%.2f%n", 
empName, empCity, empSalary);
}
}
}

Pattern Matching with instanceof

3. Type Pattern Matching

// Hierarchy of shapes
public sealed interface Shape 
permits Circle, Rectangle, Triangle, CompositeShape {
double area();
double perimeter();
}
public record Circle(double radius) implements Shape {
public Circle {
if (radius <= 0) {
throw new IllegalArgumentException("Radius must be positive");
}
}
@Override
public double area() {
return Math.PI * radius * radius;
}
@Override
public double perimeter() {
return 2 * Math.PI * radius;
}
}
public record Rectangle(double width, double height) implements Shape {
public Rectangle {
if (width <= 0 || height <= 0) {
throw new IllegalArgumentException("Dimensions must be positive");
}
}
@Override
public double area() {
return width * height;
}
@Override
public double perimeter() {
return 2 * (width + height);
}
public boolean isSquare() {
return width == height;
}
}
public record Triangle(double side1, double side2, double side3) implements Shape {
public Triangle {
if (side1 <= 0 || side2 <= 0 || side3 <= 0) {
throw new IllegalArgumentException("Sides must be positive");
}
// Triangle inequality validation
if (side1 + side2 <= side3 || 
side1 + side3 <= side2 || 
side2 + side3 <= side1) {
throw new IllegalArgumentException("Invalid triangle sides");
}
}
@Override
public double area() {
// Heron's formula
double s = perimeter() / 2;
return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
}
@Override
public double perimeter() {
return side1 + side2 + side3;
}
}
public record CompositeShape(String name, List<Shape> components) implements Shape {
public CompositeShape {
if (components == null || components.isEmpty()) {
throw new IllegalArgumentException("Components cannot be empty");
}
}
@Override
public double area() {
return components.stream()
.mapToDouble(Shape::area)
.sum();
}
@Override
public double perimeter() {
// For composite shapes, perimeter might not be well-defined
return components.stream()
.mapToDouble(Shape::perimeter)
.sum();
}
}
// Pattern matching with instanceof
public class InstanceOfPatternMatching {
// Traditional instanceof with casting
public static String describeShapeTraditional(Shape shape) {
if (shape instanceof Circle) {
Circle circle = (Circle) shape;
return String.format("Circle with radius %.2f (area: %.2f)", 
circle.radius(), circle.area());
} else if (shape instanceof Rectangle) {
Rectangle rect = (Rectangle) shape;
return String.format("Rectangle %.2f x %.2f (area: %.2f)", 
rect.width(), rect.height(), rect.area());
} else if (shape instanceof Triangle) {
Triangle tri = (Triangle) shape;
return String.format("Triangle with sides %.2f, %.2f, %.2f", 
tri.side1(), tri.side2(), tri.side3());
} else {
return "Unknown shape";
}
}
// Modern pattern matching with instanceof (Java 16+)
public static String describeShapeModern(Shape shape) {
if (shape instanceof Circle circle) {
return String.format("Circle with radius %.2f (area: %.2f)", 
circle.radius(), circle.area());
} else if (shape instanceof Rectangle rect) {
String type = rect.isSquare() ? "Square" : "Rectangle";
return String.format("%s %.2f x %.2f (area: %.2f)", 
type, rect.width(), rect.height(), rect.area());
} else if (shape instanceof Triangle tri) {
return String.format("Triangle with sides %.2f, %.2f, %.2f (perimeter: %.2f)", 
tri.side1(), tri.side2(), tri.side3(), tri.perimeter());
} else if (shape instanceof CompositeShape comp) {
return String.format("Composite shape '%s' with %d components (total area: %.2f)",
comp.name(), comp.components().size(), comp.area());
} else {
return "Unknown shape";
}
}
// Pattern matching with additional conditions
public static String analyzeShape(Shape shape) {
if (shape instanceof Circle circle && circle.radius() > 10) {
return "Large circle: " + circle.radius();
} else if (shape instanceof Rectangle rect && rect.isSquare()) {
return "Square with side: " + rect.width();
} else if (shape instanceof Triangle tri) {
if (tri.side1() == tri.side2() && tri.side2() == tri.side3()) {
return "Equilateral triangle";
} else if (tri.side1() == tri.side2() || 
tri.side1() == tri.side3() || 
tri.side2() == tri.side3()) {
return "Isosceles triangle";
} else {
return "Scalene triangle";
}
} else {
return "Other shape";
}
}
// Processing collections with pattern matching
public static void processShapes(List<Shape> shapes) {
for (Shape shape : shapes) {
if (shape instanceof Circle circle) {
System.out.printf("Processing circle (r=%.2f)%n", circle.radius());
} else if (shape instanceof Rectangle rect) {
System.out.printf("Processing rectangle (%.2fx%.2f)%n", 
rect.width(), rect.height());
}
// Additional processing...
}
}
}

Switch Expression Patterns

4. Enhanced Switch Patterns

// Domain models for different types of events
public sealed interface Event 
permits UserEvent, SystemEvent, AuditEvent, ErrorEvent {
String id();
Instant timestamp();
String source();
}
public record UserEvent(
String id,
Instant timestamp,
String source,
String userId,
String action,
Map<String, Object> metadata
) implements Event {}
public record SystemEvent(
String id,
Instant timestamp,
String source,
String component,
String operation,
Duration duration
) implements Event {}
public record AuditEvent(
String id,
Instant timestamp,
String source,
String auditor,
String target,
String action,
boolean success
) implements Event {}
public record ErrorEvent(
String id,
Instant timestamp,
String source,
String errorType,
String message,
String stackTrace,
Severity severity
) implements Event {
public enum Severity {
LOW, MEDIUM, HIGH, CRITICAL
}
}
// Switch pattern matching examples
public class SwitchPatternMatching {
// Traditional switch statement
public static String processEventTraditional(Event event) {
if (event instanceof UserEvent) {
UserEvent userEvent = (UserEvent) event;
return "User action: " + userEvent.action();
} else if (event instanceof SystemEvent) {
SystemEvent sysEvent = (SystemEvent) event;
return "System operation: " + sysEvent.operation();
} else if (event instanceof AuditEvent) {
AuditEvent auditEvent = (AuditEvent) event;
return "Audit: " + auditEvent.action() + " - " + 
(auditEvent.success() ? "SUCCESS" : "FAILED");
} else if (event instanceof ErrorEvent) {
ErrorEvent errorEvent = (ErrorEvent) event;
return "Error: " + errorEvent.message();
} else {
return "Unknown event";
}
}
// Modern switch expression with pattern matching (Java 21+ preview)
public static String processEventModern(Event event) {
return switch (event) {
case UserEvent userEvent -> 
String.format("User %s performed: %s", 
userEvent.userId(), userEvent.action());
case SystemEvent sysEvent when sysEvent.duration().toMinutes() > 5 -> 
String.format("Long system operation: %s took %d minutes",
sysEvent.operation(), sysEvent.duration().toMinutes());
case SystemEvent sysEvent -> 
String.format("System operation: %s completed", sysEvent.operation());
case AuditEvent auditEvent when !auditEvent.success() -> 
String.format("AUDIT FAILURE: %s on %s", 
auditEvent.action(), auditEvent.target());
case AuditEvent auditEvent -> 
String.format("Audit: %s completed successfully", auditEvent.action());
case ErrorEvent errorEvent when errorEvent.severity() == ErrorEvent.Severity.CRITICAL -> 
String.format("CRITICAL ERROR: %s - %s", 
errorEvent.errorType(), errorEvent.message());
case ErrorEvent errorEvent -> 
String.format("Error [%s]: %s", 
errorEvent.severity(), errorEvent.message());
default -> "Unknown event type";
};
}
// Complex pattern matching with nested extraction
public static void analyzeEvents(List<Event> events) {
for (Event event : events) {
String analysis = switch (event) {
case UserEvent(var id, var timestamp, var source, 
var userId, var action, var metadata) -> {
if (action.equals("LOGIN")) {
yield String.format("User %s logged in from %s", userId, source);
} else if (action.equals("LOGOUT")) {
yield String.format("User %s logged out", userId);
} else {
yield String.format("User %s performed %s", userId, action);
}
}
case SystemEvent(var id, var timestamp, var source,
var component, var operation, var duration) 
when duration.toSeconds() > 60 -> {
yield String.format("Slow system operation: %s.%s took %d seconds",
component, operation, duration.toSeconds());
}
case ErrorEvent(var id, var timestamp, var source,
var errorType, var message, var stackTrace, var severity)
when severity == ErrorEvent.Severity.HIGH -> {
yield String.format("High severity error in %s: %s", source, message);
}
case null -> "Null event encountered";
default -> "Event type: " + event.getClass().getSimpleName();
};
System.out.println(analysis);
}
}
// Pattern matching with guards and complex conditions
public static String categorizeEvent(Event event) {
return switch (event) {
case UserEvent user when user.action().contains("DELETE") -> 
"DESTRUCTIVE_USER_ACTION";
case UserEvent user when user.action().contains("CREATE") -> 
"CREATIVE_USER_ACTION";
case SystemEvent sys when sys.duration().toMillis() > 5000 -> 
"LONG_RUNNING_SYSTEM_OPERATION";
case SystemEvent sys when sys.component().equals("DATABASE") -> 
"DATABASE_OPERATION";
case AuditEvent audit when !audit.success() -> 
"AUDIT_FAILURE";
case ErrorEvent error when error.severity() == ErrorEvent.Severity.CRITICAL -> 
"CRITICAL_FAILURE";
case ErrorEvent error when error.message().contains("timeout") -> 
"TIMEOUT_ERROR";
default -> "STANDARD_EVENT";
};
}
}

Custom Deconstruction Patterns

5. Creating Custom Destructuring Methods

// Traditional class with custom deconstruction
public class ComplexNumber {
private final double real;
private final double imaginary;
public ComplexNumber(double real, double imaginary) {
this.real = real;
this.imaginary = imaginary;
}
// Traditional getters
public double getReal() { return real; }
public double getImaginary() { return imaginary; }
// Custom deconstruction method
public ComplexParts deconstruct() {
return new ComplexParts(real, imaginary);
}
// Static factory method for construction
public static ComplexNumber of(double real, double imaginary) {
return new ComplexNumber(real, imaginary);
}
// Record for deconstructed parts
public record ComplexParts(double real, double imaginary) {
public ComplexNumber toComplexNumber() {
return new ComplexNumber(real, imaginary);
}
}
@Override
public String toString() {
return String.format("%.2f + %.2fi", real, imaginary);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ComplexNumber that)) return false;
return Double.compare(that.real, real) == 0 && 
Double.compare(that.imaginary, imaginary) == 0;
}
@Override
public int hashCode() {
return Objects.hash(real, imaginary);
}
}
// Custom container with deconstruction support
public class Pair<A, B> {
private final A first;
private final B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
public A first() { return first; }
public B second() { return second; }
// Deconstruction method
public Object[] deconstruct() {
return new Object[]{first, second};
}
// Pattern matching support method
public boolean matches(Class<A> firstType, Class<B> secondType) {
return firstType.isInstance(first) && secondType.isInstance(second);
}
@Override
public String toString() {
return String.format("Pair[%s, %s]", first, second);
}
// Static factory
public static <A, B> Pair<A, B> of(A first, B second) {
return new Pair<>(first, second);
}
}
// Custom deconstruction examples
public class CustomDeconstruction {
public static void processComplexNumber(ComplexNumber cn) {
// Traditional approach
double real = cn.getReal();
double imaginary = cn.getImaginary();
// Using custom deconstruction
ComplexNumber.ComplexParts parts = cn.deconstruct();
double r = parts.real();
double i = parts.imaginary();
System.out.printf("Complex number: %.2f + %.2fi%n", r, i);
}
public static void processPair(Pair<?, ?> pair) {
Object[] components = pair.deconstruct();
Object first = components[0];
Object second = components[1];
System.out.printf("Pair contains: %s and %s%n", first, second);
// Type-safe processing with pattern matching simulation
if (pair.matches(String.class, Integer.class)) {
@SuppressWarnings("unchecked")
Pair<String, Integer> stringIntPair = (Pair<String, Integer>) pair;
processStringIntPair(stringIntPair);
}
}
private static void processStringIntPair(Pair<String, Integer> pair) {
String name = pair.first();
Integer value = pair.second();
System.out.printf("String-Integer pair: %s -> %d%n", name, value);
}
// Advanced deconstruction with multiple return values
public static class DataPoint {
private final String label;
private final double[] values;
private final Map<String, Object> metadata;
public DataPoint(String label, double[] values, Map<String, Object> metadata) {
this.label = label;
this.values = values.clone(); // Defensive copy
this.metadata = new HashMap<>(metadata);
}
// Multiple deconstruction options
public BasicComponents deconstructBasic() {
return new BasicComponents(label, values.length);
}
public FullComponents deconstructFull() {
return new FullComponents(label, values, metadata);
}
public record BasicComponents(String label, int valueCount) {}
public record FullComponents(String label, double[] values, Map<String, Object> metadata) {}
public String label() { return label; }
public double[] values() { return values.clone(); } // Defensive copy
public Map<String, Object> metadata() { return new HashMap<>(metadata); }
}
}

Advanced Nesting Patterns

6. Complex Nested Pattern Matching

// Complex domain model for e-commerce
public record Customer(
String id,
String name,
Address address,
List<Order> orders,
CustomerPreferences preferences
) {
public Customer {
if (orders == null) orders = new ArrayList<>();
if (preferences == null) preferences = new CustomerPreferences();
}
public boolean hasOrders() {
return !orders.isEmpty();
}
}
public record CustomerPreferences(
boolean emailNotifications,
boolean smsNotifications,
String currency,
String language,
List<String> favoriteCategories
) {
public CustomerPreferences {
if (favoriteCategories == null) favoriteCategories = new ArrayList<>();
if (currency == null) currency = "USD";
if (language == null) language = "en";
}
}
public record Order(
String orderId,
Instant orderDate,
List<OrderItem> items,
OrderStatus status,
PaymentInfo payment,
ShippingInfo shipping
) {
public double totalAmount() {
return items.stream()
.mapToDouble(item -> item.price() * item.quantity())
.sum();
}
public boolean isShippable() {
return status == OrderStatus.CONFIRMED || status == OrderStatus.PROCESSING;
}
}
public record OrderItem(
String productId,
String productName,
int quantity,
double price,
Map<String, String> attributes
) {
public double subtotal() {
return price * quantity;
}
}
public enum OrderStatus {
PENDING, CONFIRMED, PROCESSING, SHIPPED, DELIVERED, CANCELLED
}
public record PaymentInfo(
String paymentMethod,
String transactionId,
boolean paid,
Instant paymentDate
) {}
public record ShippingInfo(
Address shippingAddress,
String carrier,
String trackingNumber,
Instant estimatedDelivery
) {}
// Advanced nested pattern matching
public class NestedPatternMatching {
// Process customer with nested pattern matching simulation
public static void analyzeCustomer(Customer customer) {
// Extract nested data
String customerName = customer.name();
Address address = customer.address();
List<Order> orders = customer.orders();
CustomerPreferences prefs = customer.preferences();
// Process address
String city = address.city();
String country = address.country();
// Process preferences
boolean wantsEmails = prefs.emailNotifications();
String preferredCurrency = prefs.currency();
System.out.printf("Customer %s in %s, %s%n", customerName, city, country);
System.out.printf("Preferences: email=%s, currency=%s%n", wantsEmails, preferredCurrency);
// Process orders with nested data
for (Order order : orders) {
processOrder(order);
}
}
private static void processOrder(Order order) {
String orderId = order.orderId();
OrderStatus status = order.status();
double total = order.totalAmount();
List<OrderItem> items = order.items();
PaymentInfo payment = order.payment();
ShippingInfo shipping = order.shipping();
System.out.printf("Order %s: %s, Total: $%.2f%n", orderId, status, total);
// Process payment info
if (payment.paid()) {
System.out.printf("  Paid via %s on %s%n", 
payment.paymentMethod(), payment.paymentDate());
}
// Process shipping if applicable
if (order.isShippable() && shipping != null) {
System.out.printf("  Shipping to %s via %s%n", 
shipping.shippingAddress().city(), shipping.carrier());
}
// Process items
for (OrderItem item : items) {
processOrderItem(item);
}
}
private static void processOrderItem(OrderItem item) {
String productName = item.productName();
int quantity = item.quantity();
double price = item.price();
double subtotal = item.subtotal();
System.out.printf("  %d x %s @ $%.2f = $%.2f%n", 
quantity, productName, price, subtotal);
}
// Complex analysis with multiple levels of nesting
public static CustomerReport generateCustomerReport(Customer customer) {
String customerId = customer.id();
String customerName = customer.name();
Address address = customer.address();
List<Order> orders = customer.orders();
// Calculate statistics
long totalOrders = orders.size();
double totalSpent = orders.stream()
.mapToDouble(Order::totalAmount)
.sum();
double averageOrderValue = totalOrders > 0 ? totalSpent / totalOrders : 0;
// Analyze order status distribution
Map<OrderStatus, Long> statusCount = orders.stream()
.collect(Collectors.groupingBy(Order::status, Collectors.counting()));
// Find most expensive order
Optional<Order> mostExpensiveOrder = orders.stream()
.max(Comparator.comparing(Order::totalAmount));
return new CustomerReport(
customerId,
customerName,
address.city(),
address.country(),
totalOrders,
totalSpent,
averageOrderValue,
statusCount,
mostExpensiveOrder.map(Order::totalAmount).orElse(0.0)
);
}
public record CustomerReport(
String customerId,
String customerName,
String city,
String country,
long totalOrders,
double totalSpent,
double averageOrderValue,
Map<OrderStatus, Long> orderStatusDistribution,
double mostExpensiveOrder
) {
public void print() {
System.out.printf("Customer Report: %s (%s)%n", customerName, customerId);
System.out.printf("Location: %s, %s%n", city, country);
System.out.printf("Orders: %d, Total Spent: $%.2f, Avg Order: $%.2f%n", 
totalOrders, totalSpent, averageOrderValue);
System.out.println("Order Status Distribution:");
orderStatusDistribution.forEach((status, count) -> 
System.out.printf("  %s: %d%n", status, count));
System.out.printf("Most Expensive Order: $%.2f%n", mostExpensiveOrder);
}
}
// Pattern matching with collections
public static void processCustomerOrders(List<Customer> customers) {
for (Customer customer : customers) {
// Extract customer data
String customerName = customer.name();
List<Order> orders = customer.orders();
// Filter and process orders
List<Order> recentOrders = orders.stream()
.filter(order -> order.orderDate().isAfter(Instant.now().minusSeconds(30 * 24 * 60 * 60)))
.collect(Collectors.toList());
List<Order> highValueOrders = recentOrders.stream()
.filter(order -> order.totalAmount() > 1000)
.collect(Collectors.toList());
// Process high-value orders
for (Order order : highValueOrders) {
processHighValueOrder(customerName, order);
}
}
}
private static void processHighValueOrder(String customerName, Order order) {
System.out.printf("High value order from %s: %s - $%.2f%n", 
customerName, order.orderId(), order.totalAmount());
// Check if order needs special shipping
if (order.totalAmount() > 5000) {
System.out.println("  -> Requires premium shipping");
}
}
}

Real-World Use Cases

7. Practical Application Examples

// API Response processing with pattern matching
public class ApiResponseProcessor {
public sealed interface ApiResponse<T> 
permits Success, Error, Loading, Empty {
boolean isSuccess();
default boolean isError() { return !isSuccess(); }
}
public record Success<T>(T data, String message, int statusCode) implements ApiResponse<T> {
@Override
public boolean isSuccess() { return true; }
}
public record Error<T>(String errorCode, String message, Throwable cause) implements ApiResponse<T> {
@Override
public boolean isSuccess() { return false; }
}
public record Loading<T>(String progressMessage) implements ApiResponse<T> {
@Override
public boolean isSuccess() { return false; }
}
public record Empty<T>() implements ApiResponse<T> {
@Override
public boolean isSuccess() { return false; }
}
// Process API responses with pattern matching
public static <T> void handleApiResponse(ApiResponse<T> response) {
switch (response) {
case Success<T> success -> {
T data = success.data();
String message = success.message();
int statusCode = success.statusCode();
System.out.printf("Success (%d): %s%n", statusCode, message);
processSuccessData(data);
}
case Error<T> error -> {
String errorCode = error.errorCode();
String errorMessage = error.message();
Throwable cause = error.cause();
System.err.printf("Error %s: %s%n", errorCode, errorMessage);
if (cause != null) {
cause.printStackTrace();
}
}
case Loading<T> loading -> {
String progress = loading.progressMessage();
System.out.println("Loading: " + progress);
}
case Empty<T> empty -> {
System.out.println("No data available");
}
}
}
private static <T> void processSuccessData(T data) {
// Type-specific processing based on data type
if (data instanceof List<?> list) {
System.out.println("Received list with " + list.size() + " items");
} else if (data instanceof Map<?, ?> map) {
System.out.println("Received map with " + map.size() + " entries");
} else if (data instanceof String str) {
System.out.println("Received string: " + str);
} else {
System.out.println("Received data: " + data);
}
}
// Process multiple API responses
public static void processMultipleResponses(List<ApiResponse<?>> responses) {
for (ApiResponse<?> response : responses) {
if (response instanceof Success<?> success) {
Object data = success.data();
System.out.println("Processing successful response with data: " + data);
} else if (response instanceof Error<?> error) {
System.err.println("Error encountered: " + error.message());
}
}
}
}
// Configuration processing with deconstruction
public class ConfigurationProcessor {
public record DatabaseConfig(
String url,
String username,
String password,
int poolSize,
Map<String, String> properties
) {
public DatabaseConfig {
if (poolSize <= 0) {
throw new IllegalArgumentException("Pool size must be positive");
}
if (properties == null) {
properties = new HashMap<>();
}
}
}
public record ServerConfig(
String host,
int port,
boolean sslEnabled,
int maxConnections,
List<String> allowedOrigins
) {
public ServerConfig {
if (port < 1 || port > 65535) {
throw new IllegalArgumentException("Invalid port number");
}
if (allowedOrigins == null) {
allowedOrigins = new ArrayList<>();
}
}
}
public record AppConfig(
String name,
String version,
DatabaseConfig database,
ServerConfig server,
Map<String, Object> features
) {
public AppConfig {
if (features == null) {
features = new HashMap<>();
}
}
}
public static void validateAndProcessConfig(AppConfig config) {
// Deconstruct configuration
String appName = config.name();
String version = config.version();
DatabaseConfig dbConfig = config.database();
ServerConfig serverConfig = config.server();
Map<String, Object> features = config.features();
// Validate database configuration
validateDatabaseConfig(dbConfig);
// Validate server configuration  
validateServerConfig(serverConfig);
// Process features
processFeatures(features);
System.out.printf("Configuration validated for %s v%s%n", appName, version);
}
private static void validateDatabaseConfig(DatabaseConfig dbConfig) {
String url = dbConfig.url();
String username = dbConfig.username();
int poolSize = dbConfig.poolSize();
if (url == null || url.isBlank()) {
throw new IllegalArgumentException("Database URL is required");
}
if (username == null || username.isBlank()) {
throw new IllegalArgumentException("Database username is required");
}
if (poolSize > 100) {
System.out.println("Warning: Large connection pool size: " + poolSize);
}
}
private static void validateServerConfig(ServerConfig serverConfig) {
String host = serverConfig.host();
int port = serverConfig.port();
boolean sslEnabled = serverConfig.sslEnabled();
if (host == null || host.isBlank()) {
throw new IllegalArgumentException("Server host is required");
}
if (sslEnabled && port == 80) {
System.out.println("Warning: SSL enabled but using HTTP port 80");
}
}
private static void processFeatures(Map<String, Object> features) {
for (Map.Entry<String, Object> entry : features.entrySet()) {
String featureName = entry.getKey();
Object featureConfig = entry.getValue();
// Pattern matching on feature configuration type
if (featureConfig instanceof Boolean enabled) {
System.out.printf("Feature %s: %s%n", featureName, enabled ? "ENABLED" : "DISABLED");
} else if (featureConfig instanceof Map<?, ?> nestedConfig) {
System.out.printf("Feature %s has nested configuration with %d settings%n", 
featureName, nestedConfig.size());
} else if (featureConfig instanceof List<?> list) {
System.out.printf("Feature %s has list configuration with %d items%n", 
featureName, list.size());
}
}
}
}

This comprehensive guide covers Java's deconstruction patterns from basic record usage to advanced nested pattern matching, providing practical examples and real-world use cases for modern Java development.