Como comparar corretamente dois números inteiros em Java?

Eu sei que se você comparar um número inteiro primitivo em caixa com uma constante como:

Integer a = 4;
if (a < 5)

a será automaticamente retirado da caixa de seleção e a comparação funcionará.

No entanto, o que acontece quando você está comparando duas caixas Integerse deseja comparar a igualdade ou menor que / maior que?

Integer a = 4;
Integer b = 5;

if (a == b)

O código acima resultará na verificação para ver se eles são o mesmo objeto ou será desassociado automaticamente nesse caso?

A respeito:

Integer a = 4;
Integer b = 5;

if (a < b)

?

Não, == entre Inteiro, Longo etc verificará a igualdade de referência - ou seja,

Integer x = ...;
Integer y = ...;

System.out.println(x == y);

isso irá verificar se xe se yreferir ao mesmo objeto em vez de objetos iguais .

assim

Integer x = new Integer(10);
Integer y = new Integer(10);

System.out.println(x == y);

é garantido para imprimir false. A inclusão de valores "pequenos" autoboxed pode levar a resultados complicados:

Integer x = 10;
Integer y = 10;

System.out.println(x == y);

Isso será impresso truedevido às regras do boxe ( seção 5.1.7 do JLS ). Ainda é usada a igualdade de referência, mas as referências são realmente iguais.

Se o valor p em caixa for um literal inteiro do tipo int entre -128 e 127 inclusive (§3.10.1), ou o literal booleano true ou false (§3.10.3) ou um caractere literal entre '\ u0000' e '\ u007f' inclusive (§3.10.4), então deixe aeb serem os resultados de quaisquer duas conversões de boxe de p. É sempre o caso em que a == b.

Pessoalmente, eu usaria:

if (x.intValue() == y.intValue())

ou

if (x.equals(y))

Como você diz, para qualquer comparação entre um tipo de invólucro ( Integer, Longetc) e um tipo numérico ( int, longetc), o valor do tipo de invólucro não é colocado em caixa e o teste é aplicado aos valores primitivos envolvidos.

Isso ocorre como parte da promoção numérica binária ( seção 5.6.2 do JLS ). Veja a documentação de cada operador individual para ver se ela é aplicada. Por exemplo, nos documentos para ==e !=( JLS 15.21.1 ):

Se os operandos de um operador de igualdade são do tipo numérico ou um é do tipo numérico e o outro é conversível (§5.1.8) em tipo numérico, a promoção numérica binária é realizada nos operandos (§5.6.2).

e para <, <=, >e >=( JLS 15.20.1 )

O tipo de cada um dos operandos de um operador de comparação numérica deve ser um tipo conversível (§5.1.8) em um tipo numérico primitivo ou ocorrerá um erro em tempo de compilação. A promoção numérica binária é realizada nos operandos (§5.6.2). Se o tipo promovido dos operandos for int ou long, será realizada uma comparação de número inteiro assinado; se esse tipo promovido for flutuante ou duplo, a comparação de ponto flutuante será realizada.

Observe como nada disso é considerado como parte da situação em que nenhum tipo é um tipo numérico.

==ainda testará a igualdade de objetos. É fácil ser enganado, no entanto:

Integer a = 10;
Integer b = 10;

System.out.println(a == b); //prints true

Integer c = new Integer(10);
Integer d = new Integer(10);

System.out.println(c == d); //prints false

Seus exemplos com desigualdades funcionarão, pois não estão definidos em Objetos. No entanto, com a ==comparação, a igualdade de objetos ainda será verificada. Nesse caso, quando você inicializa os objetos de uma primitiva in a box, o mesmo objeto é usado (para a e b). Essa é uma otimização aceitável, pois as classes de caixa primitivas são imutáveis.

Desde o Java 1.7, você pode usar o Objects.equals :

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

Retorna true se os argumentos forem iguais e false em caso contrário. Conseqüentemente, se os dois argumentos forem nulos, retornará true e se exatamente um argumento for nulo, retornará false. Caso contrário, a igualdade é determinada usando o método equals do primeiro argumento.

== verifica a igualdade de referência, no entanto, ao escrever código como:

Integer a = 1;
Integer b = 1;

Java é inteligente o suficiente para reutilizar o mesmo imutável para ae b, então isso é verdade: a == b. Curioso, escrevi um pequeno exemplo para mostrar onde o java para de otimizar desta maneira:

public class BoxingLol {
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            Integer a = i;
            Integer b = i;
            if (a != b) {
                System.out.println("Done: " + i);
                System.exit(0);
            }
        }
        System.out.println("Done, all values equal");
    }
}

Quando eu compilo e executo isso (na minha máquina), recebo:

Done: 128

A minha opinião é usar um unário +para acionar o unboxing de um dos operandos ao verificar a igualdade de valor e simplesmente usar os operadores matemáticos. A justificativa a seguir:

Já foi mencionado que ==comparação para Integeré comparação de identidade, o que geralmente não é o que um programador deseja e que o objetivo é fazer comparação de valor; Ainda assim, eu fiz um pouco de ciência sobre como fazer essa comparação com mais eficiência, tanto em termos de compactação de código, correção e velocidade.

Eu usei o monte de métodos usual:

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;
}

e obteve esse código após a compilação e descompilação:

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;
    }
}

Como você pode ver facilmente, o método 1 chama Integer.equals()(obviamente), os métodos 2-4 resultam exatamente no mesmo código , desembrulhando os valores por meio de.intValue() e comparando-os diretamente, e o método 5 apenas aciona uma comparação de identidade, sendo a maneira incorreta de comparar valores.

Como (como já mencionado por exemplo, JS) equals()incorre em uma sobrecarga (é necessário fazer instanceofe uma conversão não verificada), os métodos 2 a 4 funcionam exatamente com a mesma velocidade, notavelmente melhor que o método 1 quando usado em loops apertados, já que o HotSpot não é provável otimizar os elencos & instanceof.

É bem parecido com outros operadores de comparação (por exemplo, </ >) - eles acionam o unboxing, enquanto o uso compareTo()não - mas desta vez, a operação é altamente otimizável pelo HS, poisintValue() é apenas um método getter (principal candidato a ser otimizado).

Na minha opinião, a versão 4 raramente usada é a maneira mais concisa - todo desenvolvedor experiente de C / Java sabe que o unary plus é na maioria dos casos igual a convertido para int/ .intValue()- embora possa ser um pouco WTF para alguns (principalmente aqueles que não usar o unário mais durante a vida útil), mostra sem dúvida a intenção de maneira mais clara e concisa - mostra que queremos um intvalor de um dos operandos, forçando o outro valor a desmarcar também. Também é indiscutivelmente o mais semelhante à i1 == i2comparação regular usada para intvalores primitivos .

Meu voto é para i1 == +i2& i1 > i2style para Integerobjetos, tanto por questões de desempenho quanto de consistência. Também torna o código portável para primitivas sem alterar nada além da declaração de tipo. Usar métodos nomeados parece introduzir ruído semântico para mim, semelhante ao bigInt.add(10).multiply(-3)estilo muito criticado .

Chamando

if (a == b)

Funcionará na maioria das vezes, mas não é garantido que funcione sempre, portanto, não o use.

A maneira mais adequada de comparar duas classes Inteiras para igualdade, assumindo que elas sejam nomeadas 'a' e 'b', é chamar:

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

Você também pode usar esse caminho que é um pouco mais rápido.

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

Na minha máquina, 99 bilhões de operações levaram 47 segundos usando o primeiro método e 46 segundos usando o segundo método. Você precisaria comparar bilhões de valores para ver qualquer diferença.

Observe que 'a' pode ser nulo, pois é um objeto. A comparação dessa maneira não causará uma exceção de ponteiro nulo.

Para comparar maior e menor que, use

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");
}

Devemos sempre usar o método equals () para comparação de dois números inteiros. É a prática recomendada.

Se compararmos dois números inteiros usando ==, isso funcionaria para determinado intervalo de valores inteiros (número inteiro de -128 a 127) devido à otimização interna da JVM.

Veja exemplos:

Caso 1:

Inteiro a = 100; Inteiro b = 100;

if (a == b) {
    System.out.println("a and b are equal");
} else {
   System.out.println("a and b are not equal");
}

No caso acima, a JVM usa o valor de aeb do conjunto em cache e retorna a mesma instância do objeto (portanto, endereço de memória) do objeto inteiro e obtemos os dois iguais. Sua otimização é feita pela JVM para determinados valores de intervalo.

Caso 2: Nesse caso, aeb não são iguais porque não vem com o intervalo de -128 a 127.

Inteiro a = 220; Número inteiro b = 220;

if (a == b) {
    System.out.println("a and b are equal");
} else {
   System.out.println("a and b are not equal");
}

A maneira certa:

Integer a = 200;             
Integer b = 200;  
System.out.println("a == b? " + a.equals(b)); // true

Eu espero que isso ajude.

No meu caso, eu tive que comparar dois Integers para a igualdade, onde ambos poderiam estar null. Pesquisou um tópico semelhante, não encontrou nada de elegante para isso. Veio com um simples utilitário de funções.

public static boolean integersEqual(Integer i1, Integer i2) {
    if (i1 == null && i2 == null) {
        return true;
    }
    if (i1 == null && i2 != null) {
        return false;
    }
    if (i1 != null && i2 == null) {
        return false;
    }
    return i1.intValue() == i2.intValue();
}

//considering null is less than not-null
public static int integersCompare(Integer i1, Integer i2) {
    if (i1 == null && i2 == null) {
        return 0;
    }
    if (i1 == null && i2 != null) {
        return -1;
    }
    return i1.compareTo(i2);
}

Como o método de comparação deve ser feito com base no tipo int (x == y) ou na classe Inteiro (x.equals (y)) com o operador correto

public class Example {

    public static void main(String[] args) {
     int[] arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<arr.length-1; j++)
            if((arr[j-1]!=arr[j]) && (arr[j]!=arr[j+1])) 
                System.out.println("int>"+arr[j]);


    Integer[] I_arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<I_arr.length-1; j++)
            if((!I_arr[j-1].equals(I_arr[j])) && (!I_arr[j].equals(I_arr[j+1]))) 
                System.out.println("Interger>"+I_arr[j]);
    }
}

esse método compara dois números inteiros com verificação nula, consulte testes

public static boolean compare(Integer int1, Integer int2) {
    if(int1!=null) {
        return int1.equals(int2);
    } else {
        return int2==null;
    }
    //inline version:
    //return (int1!=null) ? int1.equals(int2) : int2==null;
}

//results:
System.out.println(compare(1,1));           //true
System.out.println(compare(0,1));           //false
System.out.println(compare(1,0));           //false
System.out.println(compare(null,0));        //false
System.out.println(compare(0,null));        //false
System.out.println(compare(null,null));     //true