Programming Fundamentals and Code Quality Questions

public class MergeSortedArrays {
    public static int[] mergeSorted(int[] A, int[] B) {
        int m = A == null ? 0 : A.length;
        int n = B == null ? 0 : B.length;
        int[] res = new int[m + n];
        int i = 0, j = 0, k = 0;

        while (i < m && j < n) {
            if (A[i] <= B[j]) {
                res[k++] = A[i++];
            } else {
                res[k++] = B[j++];
            }
        }
        while (i < m) res[k++] = A[i++];
        while (j < n) res[k++] = B[j++];

        return res;
    }
}

import java.io.*;
import java.nio.file.*;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

public class FileProducerConsumer {
    private static final String POISON = new String("__POISON__");
    private final BlockingQueue<String> queue;
    private final ExecutorService prodPool;
    private final ExecutorService consPool;
    private final AtomicReference<Exception> error = new AtomicReference<>();

    public FileProducerConsumer(int queueCapacity, int producerThreads, int consumerThreads) {
        this.queue = new ArrayBlockingQueue<>(queueCapacity);
        this.prodPool = Executors.newFixedThreadPool(producerThreads);
        this.consPool = Executors.newFixedThreadPool(consumerThreads);
    }

    public void run(List<Path> inputFiles, OutputStream sink, int consumerCount) throws Exception {
        CountDownLatch producersDone = new CountDownLatch(inputFiles.size());

        // Start consumers
        for (int i = 0; i < consumerCount; i++) {
            consPool.submit(() -> {
                try (BufferedWriter out = new BufferedWriter(new OutputStreamWriter(sink))) {
                    while (true) {
                        String line = queue.take();
                        if (line == POISON) {
                            break;
                        }
                        // Process line (example: uppercase) and write to sink
                        String processed = line.toUpperCase();
                        synchronized (out) { // synchronize writes to shared sink
                            out.write(processed);
                            out.newLine();
                        }
                    }
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    error.compareAndSet(null, ie);
                } catch (Exception e) {
                    error.compareAndSet(null, e);
                }
            });
        }

        // Start producers
        for (Path p : inputFiles) {
            prodPool.submit(() -> {
                try (BufferedReader r = Files.newBufferedReader(p)) {
                    String line;
                    while ((line = r.readLine()) != null) {
                        // If an error was recorded, stop producing
                        if (error.get() != null) break;
                        // Use offer with timeout to be responsive to interrupts
                        boolean offered = false;
                        while (!offered) {
                            try {
                                offered = queue.offer(line, 500, TimeUnit.MILLISECONDS);
                                if (Thread.currentThread().isInterrupted()) throw new InterruptedException();
                                if (error.get() != null) break;
                            } catch (InterruptedException ie) {
                                Thread.currentThread().interrupt();
                                throw ie;
                            }
                        }
                        if (error.get() != null) break;
                    }
                } catch (Exception e) {
                    error.compareAndSet(null, e);
                } finally {
                    producersDone.countDown();
                }
            });
        }

        // Wait for producers, then insert poison pills
        producersDone.await();
        // Insert one poison per consumer to ensure each can exit
        for (int i = 0; i < consumerCount; i++) {
            // best-effort insertion; if interrupted, set error and break
            try {
                queue.put(POISON);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                error.compareAndSet(null, ie);
            }
        }

        // shutdown pools and wait
        prodPool.shutdownNow();
        consPool.shutdown();
        if (!consPool.awaitTermination(30, TimeUnit.SECONDS)) {
            consPool.shutdownNow();
        }

        Exception ex = error.get();
        if (ex != null) throw ex;
    }
}

import java.nio.ByteBuffer;
import java.util.BitSet;
import java.util.Objects;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class BloomFilter {
    private final BitSet bits;
    private final int m;
    private final int k;
    private final long expectedInsertions;
    private final double fpp;

    public BloomFilter(long expectedInsertions, double fpp) {
        if (expectedInsertions <= 0 || fpp <= 0.0 || fpp >= 1.0)
            throw new IllegalArgumentException();
        this.expectedInsertions = expectedInsertions;
        this.fpp = fpp;
        this.m = (int) Math.ceil(- (expectedInsertions * Math.log(fpp)) / (Math.log(2) * Math.log(2)));
        this.k = Math.max(1, (int) Math.round((m / (double) expectedInsertions) * Math.log(2)));
        this.bits = new BitSet(m);
    }

    public void add(byte[] item) {
        long[] hashes = hash128(item);
        long h1 = hashes[0], h2 = hashes[1];
        for (int i = 0; i < k; i++) {
            int idx = (int) ((Math.floorMod(h1 + (long) i * h2, Integer.MAX_VALUE)) % m);
            bits.set(idx);
        }
    }

    public boolean mightContain(byte[] item) {
        long[] hashes = hash128(item);
        long h1 = hashes[0], h2 = hashes[1];
        for (int i = 0; i < k; i++) {
            int idx = (int) ((Math.floorMod(h1 + (long) i * h2, Integer.MAX_VALUE)) % m);
            if (!bits.get(idx)) return false;
        }
        return true;
    }

    public void merge(BloomFilter other) {
        Objects.requireNonNull(other);
        if (this.m != other.m || this.k != other.k)
            throw new IllegalArgumentException("Incompatible filters");
        this.bits.or(other.bits);
    }

    public long bitSize() { return m; }
    public long memoryBytes() { return (m + 7) / 8; }

    // Simple 128-bit hash via SHA-256 truncated (replace with Murmur3 for speed)
    private long[] hash128(byte[] data) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(data);
            ByteBuffer bb = ByteBuffer.wrap(digest);
            long h1 = bb.getLong();
            long h2 = bb.getLong();
            return new long[] {h1, h2};
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
}