Поведение Java Integer Wrapper [дубликат]

Начиная с Java 1.7 вы можете использовать Objects.equals :

java.util.Objects.equals(oneInteger, anotherInteger);

Возвращает true, если аргументы равны друг другу и false в противном случае. Следовательно, если оба аргумента равны null, возвращается true, и если только один аргумент имеет значение null, возвращается false. В противном случае равенство определяется с помощью метода equals первого аргумента.

Вызов

if (a == b)

Будет работать большую часть времени, но он не всегда будет работать, поэтому не используйте его.

Самый правильный способ сравнения двух целых чисел классы для равенства, считая, что они называются 'a' и 'b', должны вызывать:

if(a != null && a.equals(b)) {
  System.out.println("They are equal");
}

Вы также можете использовать этот способ, который немного быстрее.

   if(a != null && b != null && (a.intValue() == b.intValue())) {
      System.out.println("They are equal");
    } 

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

Обратите внимание, что «a» может быть пустым, поскольку это объект. Сравнение таким образом не приведет к исключению нулевого указателя.

Для сравнения большего и меньшего, используйте

if (a != null && b!=null) {
    int compareValue = a.compareTo(b);
    if (compareValue > 0) {
        System.out.println("a is greater than b");
    } else if (compareValue < 0) {
        System.out.println("b is greater than a");
    } else {
            System.out.println("a and b are equal");
    }
} else {
    System.out.println("a or b is null, cannot compare");
}

tl; dr Мое мнение состоит в том, чтобы использовать унарный +, чтобы вызвать unboxing на одном из операндов при проверке равенства значений и просто использовать математические операторы в противном случае. Обоснование следует:

Уже упоминалось, что сравнение == для Integer - сравнение идентичности, которое обычно не то, что хочет программист, и что целью является сравнение значений; Тем не менее, я сделал немного science о том, как сделать это сравнение наиболее эффективно, как с точки зрения компактности, правильности и скорости кода.

Я использовал обычную кучу методов :

public boolean method1() {
    Integer i1 = 7, i2 = 5;
    return i1.equals( i2 );
}

public boolean method2() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2.intValue();
}

public boolean method3() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2;
}

public boolean method4() {
    Integer i1 = 7, i2 = 5;
    return i1 == +i2;
}

public boolean method5() { // obviously not what we want..
    Integer i1 = 7, i2 = 5;
    return i1 == i2;
}

и получил этот код после компиляции и декомпиляции:

public boolean method1() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    return var1.equals( var2 );
}

public boolean method2() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method3() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method4() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method5() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2 == var1 ) {
        return true;
    } else {
        return false;
    }
}

Как вы можете легко видеть, метод 1 вызывает Integer.equals() (очевидно), методы 2-4 приведут к точно к тому же коду , разворачивая значения с помощью .intValue(), а затем сравнивая их напрямую, а метод 5 просто запускает сравнение идентичности, являясь неправильным способом сравнения значений.

Поскольку (как уже упоминалось, например, JS) equals() несет накладные расходы (он должен делать instanceof и неконтролируемый отбор), методы 2-4 будут работать с точно такой же скоростью, заметно лучше, чем метод 1, когда используется в жестких петлях, поскольку HotSpot вряд ли оптимизирует отливки & amp; instanceof.

Это очень похоже на другие операторы сравнения (например, < / >) - они вызовут unboxing, в то время как использование compareTo() не будет - но на этот раз операция очень оптимизирован HS, поскольку intValue() - всего лишь метод getter (главный кандидат на оптимизацию).

На мой взгляд, редко используемая версия 4 является наиболее кратким способом - каждый опытный разработчик C / Java знает, что унарный плюс в большинстве случаев равен касту на int / .intValue() - в то время как для некоторых (немного) WTF момент для некоторых (в основном тех, кто не использовал унарный плюс в своей жизни ), он, возможно, показывает намерение наиболее четко и наиболее кратко - он показывает, что мы хотим значение int одного из операндов, заставляя другое значение также распаковываться. Также неоспоримо наиболее похож на обычном i1 == i2 сравнение используется для примитивных int значений

Мой голос идет на i1 == +i2 и усилитель. i1 > i2 для объектов Integer, как для производительности, так и для причинам согласованности. Он также переносит код в примитивы, не изменяя ничего, кроме объявления типа. Использование названных методов похоже на введение семантического шума для меня, похоже на сильно критикуемый стиль bigInt.add(10).multiply(-3).