Claude 4 vs. GPT-5: Code Generation Hallucination Rates in Production Java 26 Apps

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

// Java 26 Sealed Interface: Restricts permitted implementations to 3 records
public sealed interface PaymentResult permits PaymentResult.Success, PaymentResult.Failure, PaymentResult.Pending {
    // Nested records for compact, immutable result types (Java 26 record enhancements)
    record Success(String transactionId, double amount, Instant timestamp) implements PaymentResult {
        public Success {
            if (amount <= 0) throw new IllegalArgumentException(\"Amount must be positive\");
            if (transactionId == null || transactionId.isBlank()) throw new IllegalArgumentException(\"Transaction ID cannot be blank\");
        }
    }

    record Failure(String errorCode, String message, Instant timestamp) implements PaymentResult {
        public Failure {
            if (errorCode == null || errorCode.isBlank()) throw new IllegalArgumentException(\"Error code cannot be blank\");
        }
    }

    record Pending(String transactionId, Instant queuedAt) implements PaymentResult {
        public Pending {
            if (transactionId == null || transactionId.isBlank()) throw new IllegalArgumentException(\"Transaction ID cannot be blank\");
        }
    }
}

// Payment request DTO with validation (Java 26 record with compact constructor)
public record PaymentRequest(String userId, double amount, String paymentMethod, String currency) {
    public PaymentRequest {
        if (userId == null || userId.isBlank()) throw new IllegalArgumentException(\"User ID cannot be blank\");
        if (amount <= 0) throw new IllegalArgumentException(\"Amount must be positive\");
        if (!Set.of(\"USD\", \"EUR\", \"GBP\").contains(currency)) throw new IllegalArgumentException(\"Unsupported currency: \" + currency);
    }
}

// Core payment processor using Java 26 pattern matching in switch
public class PaymentProcessor {
    private static final Set SUPPORTED_METHODS = Set.of(\"CREDIT_CARD\", \"DEBIT_CARD\", \"BANK_TRANSFER\");

    public PaymentResult process(PaymentRequest request) {
        // Validate payment method first
        if (!SUPPORTED_METHODS.contains(request.paymentMethod())) {
            return new PaymentResult.Failure(\"UNSUPPORTED_METHOD\", \"Invalid payment method: \" + request.paymentMethod(), Instant.now());
        }

        try {
            // Simulate payment gateway call (in real app, this would be a virtual thread or reactive call)
            String transactionId = UUID.randomUUID().toString();
            // Java 26 pattern matching for switch: exhaustive, no default needed for sealed types
            switch (request.paymentMethod()) {
                case \"CREDIT_CARD\", \"DEBIT_CARD\" -> {
                    // Simulate gateway latency
                    Thread.sleep(100);
                    return new PaymentResult.Success(transactionId, request.amount(), Instant.now());
                }
                case \"BANK_TRANSFER\" -> {
                    // Bank transfers take longer, queue for processing
                    return new PaymentResult.Pending(transactionId, Instant.now());
                }
                // No default needed: sealed switch covers all cases
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new PaymentResult.Failure(\"INTERRUPTED\", \"Payment processing interrupted\", Instant.now());
        } catch (Exception e) {
            return new PaymentResult.Failure(\"GATEWAY_ERROR\", \"Payment gateway failed: \" + e.getMessage(), Instant.now());
        }
    }

    // Helper method to check result type without instanceof (Java 26 pattern matching)
    public static boolean isSuccessful(PaymentResult result) {
        return result instanceof PaymentResult.Success(String id, double amt, Instant ts);
    }
}

import java.time.Instant;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.List;
import java.util.ArrayList;

// Java 26 Sealed interface for tasks, permits 3 types
public sealed interface BackgroundTask permits BackgroundTask.EmailTask, BackgroundTask.ReportTask, BackgroundTask.CleanupTask {
    record EmailTask(String recipient, String subject, String body, Instant createdAt) implements BackgroundTask {
        public EmailTask {
            if (recipient == null || !recipient.contains(\"@\")) throw new IllegalArgumentException(\"Invalid email\");
        }
    }

    record ReportTask(String reportId, List dataSources, Instant createdAt) implements BackgroundTask {
        public ReportTask {
            if (dataSources == null || dataSources.isEmpty()) throw new IllegalArgumentException(\"No data sources\");
        }
    }

    record CleanupTask(String directory, int olderThanDays, Instant createdAt) implements BackgroundTask {
        public CleanupTask {
            if (olderThanDays <= 0) throw new IllegalArgumentException(\"Days must be positive\");
        }
    }
}

// Task scheduler using Java 26 virtual threads (default in Executors.newVirtualThreadPerTaskExecutor)
public class TaskScheduler {
    private final ExecutorService virtualThreadExecutor;

    public TaskScheduler() {
        // Java 26: Virtual thread executor is production-ready, replaces cached thread pool
        this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor();
    }

    // Submit a task and return a Future with pattern matching result handling
    public Future submit(BackgroundTask task) {
        return virtualThreadExecutor.submit(() -> processTask(task));
    }

    // Process task using Java 26 exhaustive switch pattern matching
    private TaskResult processTask(BackgroundTask task) {
        try {
            return switch (task) {
                case BackgroundTask.EmailTask(String recipient, String subject, String body, Instant createdAt) -> {
                    // Simulate email sending
                    Thread.sleep(200);
                    yield new TaskResult.Success(task.getClass().getSimpleName() + \" completed for \" + recipient, Instant.now());
                }
                case BackgroundTask.ReportTask(String reportId, List dataSources, Instant createdAt) -> {
                    // Simulate report generation
                    Thread.sleep(500);
                    yield new TaskResult.Success(\"Report \" + reportId + \" generated from \" + dataSources.size() + \" sources\", Instant.now());
                }
                case BackgroundTask.CleanupTask(String directory, int olderThanDays, Instant createdAt) -> {
                    // Simulate cleanup
                    Thread.sleep(100);
                    yield new TaskResult.Success(\"Cleaned \" + directory + \" for files older than \" + olderThanDays + \" days\", Instant.now());
                }
            };
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new TaskResult.Failure(\"Task interrupted: \" + task, Instant.now());
        } catch (Exception e) {
            return new TaskResult.Failure(\"Task failed: \" + task + \" - \" + e.getMessage(), Instant.now());
        }
    }

    // Sealed interface for task results
    public sealed interface TaskResult permits TaskResult.Success, TaskResult.Failure {
        record Success(String message, Instant completedAt) implements TaskResult {}
        record Failure(String message, Instant completedAt) implements TaskResult {}
    }

    // Batch submit tasks and collect results
    public List submitBatch(List tasks) throws Exception {
        List> futures = new ArrayList<>();
        for (BackgroundTask task : tasks) {
            futures.add(submit(task));
        }
        List results = new ArrayList<>();
        for (Future future : futures) {
            results.add(future.get()); // Waits for virtual thread to complete
        }
        return results;
    }

    public void shutdown() {
        virtualThreadExecutor.shutdown();
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.time.Instant;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.ArrayList;

// Spring Boot 4 auto-configuration enabled (Java 26 compliant)
@SpringBootApplication
@RestController
@RequestMapping(\"/api/products\")
public class ProductServiceApplication {

    private final ProductRepository productRepository;
    private final ExecutorService virtualThreadExecutor;

    // Constructor injection (Spring Boot 4 supports Java 26 record components as beans)
    public ProductServiceApplication(ProductRepository productRepository) {
        this.productRepository = productRepository;
        // Java 26 virtual thread executor for async operations
        this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor();
    }

    // Java 26 record for create product request
    public record CreateProductRequest(String sku, String name, double price, String category) {
        public CreateProductRequest {
            if (sku == null || sku.isBlank()) throw new IllegalArgumentException(\"SKU required\");
            if (price <= 0) throw new IllegalArgumentException(\"Price must be positive\");
        }
    }

    // Java 26 record for product response
    public record ProductResponse(String sku, String name, double price, String category, Instant createdAt) {}

    // GET all products with optional category filter (virtual thread per request)
    @GetMapping
    public ResponseEntity> getAllProducts(@RequestParam Optional category) {
        try {
            List products = virtualThreadExecutor.submit(() -> {
                return productRepository.findAll(category)
                        .stream()
                        .map(p -> new ProductResponse(p.sku(), p.name(), p.price(), p.category(), p.createdAt()))
                        .toList();
            }).get();
            return ResponseEntity.ok(products);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }

    // POST new product with validation (Java 26 pattern matching for error handling)
    @PostMapping
    public ResponseEntity createProduct(@RequestBody CreateProductRequest request) {
        try {
            // Validate SKU uniqueness
            if (productRepository.existsBySku(request.sku())) {
                return ResponseEntity.status(HttpStatus.CONFLICT).body(\"SKU already exists: \" + request.sku());
            }
            // Java 26 pattern matching to handle request validation
            Object result = switch (request) {
                case CreateProductRequest(String sku, String name, double price, String category) when price > 1000 -> {
                    // High-value products require approval
                    yield productRepository.save(new Product(sku, name, price, category, Instant.now(), false));
                }
                case CreateProductRequest(String sku, String name, double price, String category) -> {
                    yield productRepository.save(new Product(sku, name, price, category, Instant.now(), true));
                }
            };
            return ResponseEntity.status(HttpStatus.CREATED).body(result);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(\"Failed to create product: \" + e.getMessage());
        }
    }

    // Simple product entity (Java 26 record with persistence annotation)
    public record Product(String sku, String name, double price, String category, Instant createdAt, boolean isActive) {}

    // In-memory repository for demo (replace with JPA in production)
    public static class ProductRepository {
        private final List products = new ArrayList<>();
        private int skuCounter = 0;

        public Product save(Product product) {
            products.add(product);
            return product;
        }

        public List findAll(Optional category) {
            return category.map(c -> products.stream().filter(p -> p.category().equals(c)).toList()).orElse(products);
        }

        public boolean existsBySku(String sku) {
            return products.stream().anyMatch(p -> p.sku().equals(sku));
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }
}

// Claude 4 batch code generation example (Anthropic Java SDK)
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;

public class Claude4BatchGenerator {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.builder()
                .apiKey(System.getenv(\"ANTHROPIC_API_KEY\"))
                .build();

        MessageCreateParams params = MessageCreateParams.builder()
                .model(\"claude-4-20241007\")
                .maxTokens(2048)
                .temperature(0.2)
                .addUserMessage(\"Generate a Java 26 sealed interface for OrderResult with permits Success, Failure, Pending records, including validation in compact constructors.\")
                .build();

        Message message = client.messages().create(params);
        System.out.println(message.content().get(0).text());
    }
}

// GPT-5 real-time code completion example (OpenAI Java SDK)
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.ChatCompletion;
import com.openai.models.chat.ChatCompletionCreateParams;

public class GPT5RealtimeCompletion {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
                .apiKey(System.getenv(\"OPENAI_API_KEY\"))
                .build();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
                .model(\"gpt-5-20240912\")
                .maxTokens(512)
                .temperature(0.1)
                .addUserMessage(\"Complete this Java 26 pattern matching switch for a PaymentResult sealed interface: switch (result) {\")
                .build();

        ChatCompletion completion = client.chatCompletions().create(params);
        System.out.println(completion.choices().get(0).message().content().get());
    }
}

// JUnit 6 test for LLM-generated PaymentResult sealed interface
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class PaymentResultTest {
    @Test
    void successRecordValidatesCorrectly() {
        PaymentResult.Success success = new PaymentResult.Success(\"txn_123\", 99.99, Instant.now());
        assertEquals(\"txn_123\", success.transactionId());
        assertEquals(99.99, success.amount());
        assertThrows(IllegalArgumentException.class, () -> new PaymentResult.Success(\"\", -10, Instant.now()));
    }

    @Test
    void failureRecordValidatesCorrectly() {
        PaymentResult.Failure failure = new PaymentResult.Failure(\"ERR_001\", \"Invalid payment\", Instant.now());
        assertEquals(\"ERR_001\", failure.errorCode());
        assertThrows(IllegalArgumentException.class, () -> new PaymentResult.Failure(\"\", \"msg\", Instant.now()));
    }

    @Test
    void patternMatchingWorksForSwitch() {
        PaymentResult result = new PaymentResult.Success(\"txn_456\", 49.99, Instant.now());
        String message = switch (result) {
            case PaymentResult.Success(String id, double amt, Instant ts) -> \"Success: \" + id;
            case PaymentResult.Failure(String code, String msg, Instant ts) -> \"Failure: \" + code;
            case PaymentResult.Pending(String id, Instant queuedAt) -> \"Pending: \" + id;
        };
        assertEquals(\"Success: txn_456\", message);
    }
}