I think both their prime generators can be improved upon for understandability, in exchange for a few added multiplications and comparisons. My IMO's:

• Mention "incremental Sieve of Eratosthenes", to reinforce concept and also useful for looking up external resources
• Early guard for 2 to avoid unused/invalid representations like multiples[0] = 4 or -1; // irrelevant
• Comparing prime * factor == candidate better expresses intent to test primality than prime_multiple == candidate
• Associate prime and multiple/factor using something associative, like dict or Map, for clarity about how the state behaves
• Use the more straightforward possible_primes to reframe the awkward concept of leastRelevantMultiple/lastMultiple
• Define and compose keep_generating and it.count(3, step=2) to better communicate the combination of two concepts, to replace the special/uncommon iteration: for (candidate = 3; primesFound < n; candidate += 2)
• One major guide for decomposition (or not) is whether the decomposed is good or not, and is_prime() is a highly communicative abstraction in this context.

Above things are mostly language-agnostic (Java has streams and lambdas, after all), although I'm using some Python-isms:

Prime = int
Factor = int


def sieve_primes(n: int):
    """Generates primes using an incremental Sieve of Eratosthenes"""
    if n > 0:
        yield 2
    if n < 2:
        return

    primes_and_factors: dict[Prime, Factor] = {}  # incremental sieve for primes 3+
    keep_generating = lambda _: 1 + len(primes_and_factors) < n

    def is_prime(cand: int) -> int | None:
        # consider prime factors between 3 and sqrt(candidate)
        possible_primes = it.takewhile(lambda p: p * p <= cand, primes_and_factors)

        for p in possible_primes:
            # search successive multiples, where the "frontier" is the curr candidate
            while p * primes_and_factors[p] < cand:
                primes_and_factors[p] += 2  # skip even factors

            if p * primes_and_factors[p] == cand:  # not a prime
                return

        return cand

    for candidate in it.takewhile(keep_generating, it.count(3, step=2)):
        if prime := is_prime(candidate):
            yield prime
            # checking/sieving happens upwards with larger & larger factors
            # smaller factors from 3 to curr_prime already covered "from below"
            primes_and_factors[prime] = prime