NumberFormatException while converting binary string to integer

Short answer:

The Integer.parseInt() method (which is a method called by Integer.valueOf()) requires you to tell it if the number is negative, because it is not designed handle signed numbers. "Fix" your code by adding a minus:

Integer sInt = Integer.valueOf("-10000000000000000000000000000000", 2);
System.out.println(sInt); // prints -2147483648

Long answer:

Your stacktrace tells you where you can find out where things go wrong. Your Integer.valueOf() method calls Integer.parseInt(), which in turn throws a NumberFormatException on line 583. You can find the code for the Integer class in the openjdk.

public static int parseInt(String s, int radix) throws NumberFormatException {
    int result = 0;
    int i = 0, len = s.length();
    int limit = -Integer.MAX_VALUE;
    int multmin;
    int digit;

    if (len > 0) {
        char firstChar = s.charAt(0);
        if (firstChar < '0') { // Possible leading "+" or "-"
            if (firstChar == '-') {
                negative = true;
                limit = Integer.MIN_VALUE;
            } else if (firstChar != '+')
                throw NumberFormatException.forInputString(s);
        }

        multmin = limit / radix;
        while (i < len) {
            digit = Character.digit(s.charAt(i++),radix);
            if (result < multmin) {
                throw NumberFormatException.forInputString(s);
            }
            result *= radix;
            result -= digit;
        }
    } else {
        throw NumberFormatException.forInputString(s);
    }
    return negative ? result : -result;
}

I've removed the parts of the code that our current example does not run through for clarification. Note that limit is -2147483647 (one over the MIN_VALUE)! Likewise, multmin is -1073741823. In the first iteration of the loop, result is 0, so result*radix is 0 and digit is 1 (that's the first number in our String), so result - digit is -1. In the second iteration, digit becomes 0, but now result * radix is -2. In the third iteration, we get -4, then -8, etc... This goes on all the way until result equals -1073741824, which is one fewer than our limit.

Now, we can also see that the method checks if we added a sign (+ or -) to our number. Interestingly, if we do add a minus, we see that limit is set to MIN_VALUE. So, counterintuitively, we can simply "fix" your code by adding a minus:

Integer sInt = Integer.valueOf("-10000000000000000000000000000000", 2);
System.out.println(sInt); // prints -2147483648

On another note, you do some weird casting there. Instead of:

sByte= (byte)(int)Integer.valueOf("10000000", 2);

You should be able to write:

sByte = Byte.valueOf("10000000", 2);

I Say "should", because actually you can't. This results in another exception! This is because the Byte.valueOf() method simple calls the Integer.valueOf() method and then casts the answer to a Byte! And because 10000000 for an Integer is 000...00010000000 = 128, it will tell you that that is too large for a Byte.

Whoa! So why does your weird casting trick work? Because of a thing called "silent overflow". Java recognizes you desperately want to fit the number 128 in a Byte, which is not possible, so it puts as many as it can into it (127) and it wraps around to the bottom by adding the remaining 1, leaving you with -128. I suppose this is what silent overflow was designed for, but depending on it is definitely a bad idea. To illustrate what happens in your line:

sByte= (byte)(int)Integer.valueOf("10000000", 2);

Integer a = Integer.valueOf("10000000", 2);
System.out.println(a);        // 128
int b = (int)a;
System.out.println(b);        // 128
byte sByte = (byte)b;
System.out.println(sByte);    // -128

So, don't use parseInt() or valueOf() on signed numbers.

convert to Long and then long to Int like this in kotlin

try {
    val binaryString = "10010100101111111111000010100001"
    if (binaryString.isEmpty()) println("number is empty")
    else {
        val number = binaryString.toLong(2)
        println("number is ${number.toInt()}")
  }

} catch (e: Exception) {
    e.stackTrace.forEach {
        kotlin.io.println("number is ${it.toString()}")
    }
}