Let's Break Down the Party by Breaking the Party Down Recursively
I decided to introduce a quantize() method on Denomination to do the multiplication:

public static int quantize(double input) {
    return (int) (input * MULTIPLIER);
}


This changes the Denomination's constructor:

this.centValue = quantize(value);


And the helper method itself:

public static Map&lt;Denomination, Integer&gt; getBreakdownRecursively(double input) {
    return recurse(Stream.of(Denomination.values()).iterator(),
            Denomination.quantize(input), new EnumMap&lt;&gt;(Denomination.class));
}


As hinted from above, I moved the Collections.unmodifiableMap() call to the last recursion within the recurse() method:

private static Map&lt;Denomination, Integer&gt; recurse(Iterator&lt;Denomination&gt; iterator,
        int input, Map&lt;Denomination, Integer&gt; result) {
    if (input == 0 || !iterator.hasNext()) {
        return Collections.unmodifiableMap(result);
    }
    Denomination current = iterator.next();
    ...
}


Now, the original approach described in the question works well and looks simple enough, but what if I went a little deeper with Java 8 features? Looks like a nice place to introduce Map.computeIfAbsent()...

private static Map&lt;Denomination, Integer&gt; recurse(Iterator&lt;Denomination&gt; iterator,
        int input, Map&lt;Denomination, Integer&gt; result) {
    if (input == 0 || !iterator.hasNext()) {
        return Collections.unmodifiableMap(result);
    }
    Denomination current = iterator.next();
    return recurse(iterator, result.computeIfAbsent(current, key -&gt;
                Optional.of(Integer.valueOf(input / key.getCentValue()))
                    .filter(i -&gt; i.intValue() != 0).orElse(null)) == null ? 
                        input : input % current.getCentValue(), result);
}


Sure, readability is sacrificed, but hey, just one return statement! By taking advantage of computeIfAbsent() and its return type, I can optionally store the output of the current iteration's breakdown (when the quotient is not zero), and determine what should be the next value to recuse with (the original input, or the modulus).

edit

I suppose I can improve the readability somewhat by this...

private static Integer getValue(int input) {
    // return Optional.of(Integer.valueOf(input))
    //                 .filter(i -&gt; i.intValue() != 0).orElse(null);
    return input == 0 ? null : Integer.valueOf(input);
}


(fixed that)

The return statement will then read:

private static Map&lt;Denomination, Integer&gt; recurse(Iterator&lt;Denomination&gt; iterator,
        int input, Map&lt;Denomination, Integer&gt; result) {
    if (input == 0 || !iterator.hasNext()) {
        return Collections.unmodifiableMap(result);
    }
    Denomination current = iterator.next();
    return recurse(iterator, result.computeIfAbsent(current, key -&gt;
                getValue(input / key.getCentValue())) == null ? 
                        input : input % current.getCentValue(), result);
}