TL; DR A miña opinión é usar un + Unario para activar o desempaquetado nun dos operandos ao verificar os valores iguais e simplemente usar operadores matemáticos doutro xeito. A Lóxica segue:
Xa se mencionou que a comparación
para Integer é a comparación de identidade, que Xeralmente non é o que quere un programador, e que o obxectivo é facer unha comparación de valores; Aínda así, fixen unha pequena ciencia sobre como facer esa comparación de forma máis eficiente, tanto en termos de compacidade de código, corrección e velocidade.
Eu usei os métodos habituais:
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 obtén este código despois da compilación e descompilación:
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 pode ver facilmente o método 1 chamada Integer.equals() (obviamente), os métodos 2-4 resultan exactamente no mesmo código, desenvolven os valores mediante .intValue() e A continuación, compara-los directamente, eo método 5 simplemente activa unha comparación de identidade, sendo a forma incorrecta de comparar valores.
Dado que (como xa mencionado, por exemplo, JS) equals() incurre unha sobrecarga (ten que facer instanceof e unha conversión non probada), os métodos 2-4 funcionarán exactamente coa mesma velocidade, mellor que o método 1 cando Utilizan lazos axustados, xa que o punto de acceso non é probable que optimice o &
.
é bastante similar con outra comparación operadores (por exemplo, < / >): active a desembarque, mentres usa non, pero esta vez, a operación é moi optimizable por HS desde que intValue() é só un método de getter (o principal candidato a ser optimizado fóra).
no meu Opinión, a versión 4, que se usa con pouca frecuencia, é a forma máis concisa: todos os desenvolvedores de C / Java experimentados saben que a vantaxe nonaría na maioría dos casos é igual á conversión a int / .intValue() – Aínda que pode ser un poucowtfmomento para algúns (principalmente aqueles que non utilizaron uny plus na súa vida), podería dicir que mostra a máis claridade e lixeiramente a intención: mostras A que queremos un valor int dun dos operandos, forzando o outro valor a unxolo. Tamén é indiscutiblemente máis similar á comparación i1 == i2 usado regularmente para os valores primitivos int.