Почему (i <= j && j <= я && я!= J) оценивается как TRUE?

Я написал фрагмент кода Java, который работает в бесконечном цикле.

Ниже приведен код:

public class TestProgram {
    public static void main(String[] args){
        Integer i = new Integer(0);
        Integer j = new Integer(0);

        while(i<=j && j<=i && i!=j){
            System.out.println(i);
        }
    }
}

В приведенном выше коде, видя условие в цикле while, сначала похоже, что эта программа не войдет в цикл while. Но на самом деле это бесконечный цикл и сохраняет печать значения.

Что здесь происходит?

Ответ 1

i <= j оценивается как true, поскольку автоматическое разблокирование происходит для int сравнения, а затем i и j сохраняют значение по умолчанию 0.
j <= i оценивается по true по вышеуказанной причине.
i != j оценивается как true, поскольку оба i и j равны разные объекты. И при сравнении объектов, нет необходимости в auto unboxing.

Все условия верны, и вы не меняете i и j в цикле, поэтому он работает бесконечно.

Ответ 2

Потому что вы сравниваете

0 < = 0 (true) // unboxing
0 > = 0 (true) // unboxing
reference != secondReference (true), поскольку вы создаете объекты, а не примитивное сравнение. Поэтому он оценивает значение while(true) { // Never ending loop }.

Ответ 3

Целые объекты разные. Он отличается от базового типа int.

См. этот ответ: Как правильно сравнить два целых числа в Java?

Часть i != j является истиной, которую вы ожидали быть ложной.

Ответ 4

Цикл не заканчивается, потому что ваше условие истинно (i!= j является истинным, потому что есть два разных объекта, вместо этого используйте Integer.valueOf), и внутри цикла значения не изменяются, поэтому ваше условие остается истинным навсегда.

Ответ 5

Целые объекты разные. Он отличается от базового типа int. так что вы можете просто так. что вы делаете, просто сравниваете объект, и, конечно, результат верен.

Ответ 6

Есть два разных случая, которые мы должны понять сначала:

случай 1:

        Integer i = new Integer(10);
        Integer j = new Integer(10);

        System.out.println((i<=j && j<=i && i!=j));
        System.out.println(i!=j);

случай 2:

        Integer i = 10;
        Integer j = 10;

        System.out.println((i<=j && j<=i && i==j));
        System.out.println(i==j);

оба разные, поскольку

в случае 1: i!=j будет true, потому что оба ссылаются на два разных объекта в куче и не могут быть одинаковыми. Но

в случае 2: i==j будет true, потому что оба 10 являются целыми литералами, а Java поддерживает pool for Integer literals, которые имеют значение (-128 <= X <= 127). Таким образом, в этом случае 10 <= 127 верны, то оба будут иметь ссылку на тот же объект.

Ответ 7

Возможно, причина в том, что оба "i" и "j" являются объектами, а сравнение объектов не совпадает с сопоставлением объектных ссылок. Пожалуйста, подумайте об использовании! I.equals(j) вместо я!= J

Ответ 8

Программа продолжает показывать то же значение i, потому что вы не увеличиваете или не уменьшаете значение i или j. Условие в for всегда сохраняет значение true, поэтому это бесконечный цикл.

Ответ 9

Целое число a = новое целое число (0); Integer b = новое целое число (0);

Сравнение <= и >= будет использовать значение unboxed 0, тогда как!= будет сравнивать ссылки и будет успешным, так как они являются разными объектами.

Даже это также будет работать i, e

Целое число a = 1000; Целое число b = 1000;

но это не делает:

Целое число a = 100; Целое число b = 100;

Причина в том, что Integer внутренне использует кеширование для объектов Integer между -128 и 127 и возвращает экземпляры из этого кеша для диапазона, который он охватывает. Я не уверен, но я думаю, вы также можете изменить его максимальное значение в пакете "java.lang.Integer.IntegerCache.high".

Для лучшего понимания проверьте URL: https://www.owasp.org/index.php/Java_gotchas#Immutable_Objects_.2F_Wrapper_Class_Caching

Ответ 10

вы должны знать, что он немного отличается от && это и это, и когда вы используете && тогда, когда первое условие истинно, тогда оно проверяет второе условие, если его ложное, а затем не проверено третье условие, потому что in и operator, если одно условие ложно, все утверждения являются ложными, если использовать || то, если он видит true, тогда он возвращает true в вашем коде, потому что я и j равны первому и второму условию true, тогда в третьем условии он будет false, потому что они равны, а условие - false.