Краткий ответ:
Метод Integer.parseInt () (который является методом, вызываемым Integer.valueOf ()) требует, чтобы вы сообщали ему, является ли число отрицательным, поскольку он не предназначен для обработки чисел со знаком. «Исправьте» свой код, добавив минус:
Integer sInt = Integer.valueOf("-10000000000000000000000000000000", 2);
System.out.println(sInt); // prints -2147483648
Длинный ответ:
Ваша трассировка стека говорит вам, где вы можете узнать, где что-то пошло не так. Ваш метод Integer.valueOf () вызывает Integer.parseInt (), который, в свою очередь, вызывает исключение NumberFormatException в строке 583. Код для класса Integer можно найти в 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;
}
Я удалил части кода, которые наш текущий пример не выполняет для пояснения. Обратите внимание, что предел -2147483647 (один сверх MIN_VALUE)! Аналогично, multmin -1073741823. В первой итерации цикла результат равен 0, поэтому результат * radix равен 0, а цифра равна 1 (это первое число в нашей строке), поэтому результат - цифра равна -1. Во второй итерации цифра становится 0, но теперь результат * radix равен -2. На третьей итерации мы получаем -4, затем -8 и т. Д. Это продолжается до тех пор, пока результат не будет равен -1073741824, что на единицу меньше нашего лимита.
Теперь мы также видим, что метод проверяет, добавили ли мы знак (+ или -) к нашему номеру. Интересно, что если мы добавим минус, мы увидим, что ограничение установлено на MIN_VALUE. Таким образом, нелогично, мы можем просто «исправить» ваш код, добавив минус:
Integer sInt = Integer.valueOf("-10000000000000000000000000000000", 2);
System.out.println(sInt); // prints -2147483648
На другой ноте, вы делаете там странный кастинг. Вместо:
sByte= (byte)(int)Integer.valueOf("10000000", 2);
Вы должны быть в состоянии написать:
sByte = Byte.valueOf("10000000", 2);
Я говорю "должен", потому что на самом деле вы не можете. Это приводит к другому исключению! Это связано с тем, что метод Byte.valueOf () просто вызывает метод Integer.valueOf (), а затем приводит ответ к байту! И поскольку 10000000 для целого числа равно 000 ... 00010000000 = 128, он скажет вам, что он слишком велик для байта.
Вау! Так почему же работает ваш странный трюк? Из-за того, что называется "тихое переполнение" Java признает, что вы отчаянно хотите поместить число 128 в байт, что невозможно, поэтому она помещает в него столько, сколько может (127), и оборачивает его снизу, добавляя оставшуюся 1, оставляя с -128 , Полагаю, именно для этого и было разработано тихое переполнение, но в зависимости от этого, безусловно, плохая идея Чтобы проиллюстрировать, что происходит в вашей строке:
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
Так что не используйте parseInt () или valueOf () для чисел со знаком.