Found a solution!

int num = -4;

String bin = binary(num);
println(bin);

int dec = (int) Long.parseLong(bin, 2);
println(dec);

unbinary( binary ) corresponds to -> Integer.parseInt( binary , 2) .
However, likewise its counterpart, it also has the same bug for binaries derived from negative int numbers.

It tries to unbinary as if a binary is always positive, that is, unsigned.
And the Integer type can't store a positive number w/ 32 bits.
Rather for a maximum of 31 bits, for it is a signed type as all of the Java primitives are but char!

So, a solution I've found would be to use the Long wrapper type in place of the Integer one:
(int) Long.parseLong( binary , 2);

The leftmost bit (32nd) is considered a negative flag for the Integer type.
However, that 32nd bit is a regular one for the Long type's point of view.
So the whole thing comes out as a really huge number!

Fortunately, after (int) is cast on it, the 32nd bit is again interpreted as a negative sign!