class D {
public static void main(String args[]) {
Integer b2=128;
Integer b3=128;
System.out.println(b2==b3);
}
}
Вывод:
false
class D {
public static void main(String args[]) {
Integer b2=127;
Integer b3=127;
System.out.println(b2==b3);
}
}
Вывод:
true
Примечание. Номера от -128 до 127 являются истинными.
Когда вы компилируете числовой литерал в Java и присваиваете ему целое число (заглавная I), компилятор выдает:
Integer b2 =Integer.valueOf(127)
Эта строка кода также генерируется при использовании автобокса.
valueOf реализовано так, что определенные числа "объединены", и оно возвращает тот же экземпляр для значений, меньших 128.
Из исходного кода Java 1.6, строка 621:
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
Значение high может быть настроено на другое значение с помощью системного свойства.
-Djava.lang.Integer.IntegerCache.high = 999
Если вы запустите вашу программу с этим системным свойством, она выдаст true!
Очевидный вывод: никогда не полагайтесь на две одинаковые ссылки, всегда сравнивайте их с .equals().
Таким образом, b2.equals(b3) выведет true для всех логически равных значений b2, b3.
Обратите внимание, что Integer кеш существует не по соображениям производительности, а скорее для соответствия JLS, раздел 5.1.7; Идентификатор объекта должен быть задан для значений -128 до 127 включительно.
Integer # valueOf (int) также документирует это поведение:
этот метод, вероятно, даст значительно лучшую производительность в пространстве и времени за счет кэширования часто запрашиваемых значений. Этот метод всегда будет кэшировать значения в диапазоне от -128 до 127 включительно и может кэшировать другие значения вне этого диапазона.
Автобокс кэширует от -128 до 127. Это указано в JLS (5.1.7).
Если значение p в штучной упаковке является истинным, ложным, байтом, символом в диапазоне от \u0000 до\u007f или целым или коротким числом между -128 и 127, то пусть r1 и r2 будут результатами любых двух боксов преобразования р. Это всегда тот случай, когда r1 == r2.
Простое правило, которое нужно помнить при работе с объектами, - используйте .equals если вы хотите проверить, равны ли два объекта, используйте == когда вы хотите увидеть, указывают ли они на один и тот же экземпляр.
Использование примитивных типов данных, ints, создало бы истинный в обоих случаях ожидаемый результат.
Однако, поскольку вы используете объекты Integer, оператор == имеет другое значение.
В контексте объектов == проверяет, ссылаются ли переменные на одну и ту же ссылку на объект.
Чтобы сравнить значение объектов, вы должны использовать метод equals() Например.
b2.equals(b1)
который укажет, является ли b2 меньше, чем b1, больше или равно (проверьте API для деталей)
Это связано с оптимизацией памяти в Java.
Для экономии памяти Java "повторно" использует все объекты-оболочки, значения которых попадают в следующие диапазоны:
Все логические значения (true и false)
Все байтовые значения
Все значения символов от \u0000 до\u007f (то есть от 0 до 127 в десятичном виде)
Все значения Short и Integer от -128 до 127.
Посмотрите на Integer.java, если значение находится между -128 и 127, оно будет использовать кешированный пул, поэтому (Integer) 1 == (Integer) 1 while (Integer) 222 != (Integer) 222
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
Я написал следующее, поскольку эта проблема не просто специфична для Integer. Мое заключение состоит в том, что чаще всего, если вы неправильно используете API, вы видите неправильное поведение. Используйте его правильно, и вы должны увидеть правильное поведение:
public static void main (String[] args) {
Byte b1=127;
Byte b2=127;
Short s1=127; //incorrect should use Byte
Short s2=127; //incorrect should use Byte
Short s3=128;
Short s4=128;
Integer i1=127; //incorrect should use Byte
Integer i2=127; //incorrect should use Byte
Integer i3=128;
Integer i4=128;
Integer i5=32767; //incorrect should use Short
Integer i6=32767; //incorrect should use Short
Long l1=127L; //incorrect should use Byte
Long l2=127L; //incorrect should use Byte
Long l3=13267L; //incorrect should use Short
Long l4=32767L; //incorrect should use Short
Long l5=2147483647L; //incorrect should use Integer
Long l6=2147483647L; //incorrect should use Integer
Long l7=2147483648L;
Long l8=2147483648L;
System.out.print(b1==b2); //true (incorrect) Used API correctly
System.out.print(s1==s2); //true (incorrect) Used API incorrectly
System.out.print(i1==i2); //true (incorrect) Used API incorrectly
System.out.print(l1==l2); //true (incorrect) Used API incorrectly
System.out.print(s3==s4); //false (correct) Used API correctly
System.out.print(i3==i4); //false (correct) Used API correctly
System.out.print(i5==i6); //false (correct) Used API correctly
System.out.print(l3==l4); //false (correct) Used API correctly
System.out.print(l7==l8); //false (correct) Used API correctly
System.out.print(l5==l6); //false (correct) Used API incorrectly
}