Los problemas comparativos en Java son muy básicos y fáciles de confundir. Hoy resumiré y organizaré un resumen y disposición más detallados de algunos puntos propensos a errores, con la esperanza de que sea útil para el estudio y la entrevista de todos.
1. La diferencia entre == y igual ()
En primer lugar, necesitamos saber la diferencia entre == y igual (). El signo == siempre se compara con el valor de la dirección. Para los tipos de datos básicos, == La comparación es en realidad si los valores variables son iguales, mientras que para los tipos de datos de referencia, se compara el valor de la dirección. A lo que debe prestar especial atención a aquí es el tipo de cadena, que es fácil de dar por sentado == y es fácil de cometer errores. El método Equals () es un método en la clase de objeto. Sabemos que todas las clases en Java heredarán la clase de objeto de forma predeterminada, por lo que los objetos de clase tendrán el método igual (). El método igual () en la clase de objeto se muestra en la figura a continuación:
Como se puede ver en el código fuente, la capa subyacente del método igual () en la clase de objeto también usa ==, por lo que en realidad es el valor de la dirección. Entonces, si queremos usar el método igual () para otras comparaciones, necesitamos anular el método igual ().
2. Tipos de datos básicos y tipos de embalaje
Todos sabemos que Byte, Short, Int, Long, Boolean, Char, Double y Float son tipos de datos básicos, y las variables que declaran se almacenan en la memoria de la pila. Las variables definidas por sus tipos de envasado correspondientes (byte, corto, entero, largo, booleano, carácter, doble) existen en la memoria del montón. Para los tipos de datos básicos, su comparación es relativamente simple, es decir, use == para determinar si son iguales y usan <,>, <=,> = para comparar los tamaños. Pero para los tipos de embalaje, es un poco diferente.
Primero, para determinar si es igual, consulte el resultado de ejecución del siguiente código:
Paquete DailyTest; import org.junit.test;/*** Resumen comparativo en java* @author yrr*/public class javacomparetest {/*** El juicio de tipo entero es igual*/@test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- n8); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------- System.out.println (N1.intvalue () == N2.intvalue ()); n6); NullPointException}/*** El juicio de tipo largo es igual*/@Test public void test02 () {// Tenga en cuenta aquí que cuando se usa una definición larga, L o L no es necesario, pero cuando se usa largo, de lo contrario se informará un error // agregarlo en construcción para indicar la diferencia larga n3 = 48L; System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- N1); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n4 == n5); // Al usar el método Long.intValue (), debe prestar atención para verificar si es nulo para evitar nullpointException}}Para los resultados de ejecución anteriores, se realiza la siguiente explicación:
Primero, para el nuevo método, declaramos un entero o objeto largo. Debido a que el nuevo objeto abre una pieza de espacio en el montón, incluso si los valores de los dos son los mismos, para ==, el valor de la dirección se compara, por lo que se devolverá falso. Para las clases de envoltura de tipos de datos básicos, el método Equals () se ha reescrito y se comparará el tamaño numérico, por lo que el método igual () se puede usar para juzgar en función del tamaño numérico. Con respecto al problema de comparar las variables enteras con las variables INT, encontraremos que el valor de comparación también se basa en el tamaño numérico. Esto se debe a que al comparar, el tipo de entero se desanimará automáticamente y se convierte al tipo int. La explicación de los primeros tres puntos es aplicable a todos los tipos de empaque. Para el método de asignación directa, las dos variables enteras con un valor de 48 se consideran verdadero por el signo ==, pero cuando el valor es 128, es falso. Esto se debe a que en la parte inferior, para entero n1 = 48;, el método de asignación directa en realidad llama al método Integer.Value (). Podemos echar un vistazo brevemente al código fuente del método Integer.Value (), como se muestra en la figura a continuación:
Podemos ver que hay un juicio si aquí. Cuando la entrada I está dentro del rango de [-128, 127], se devuelve directamente desde la matriz IntegerCache. Por lo tanto, para los valores en este rango, se devuelven los valores de la dirección correspondientes a esta matriz, por lo que se devolverá el uso del signo == para juzgar True. Lo que no está dentro de este rango es el objeto nuevo, por lo que se devolverá falso. Esta conclusión es cierta para los tipos de bytes, cortos, enteros y largos (si está interesado, puede verificar el código fuente del método de valor () correspondiente), porque el alcance del tipo de byte es [-128, 127], por lo que para el tipo de byte, usar == no es diferente de igual ().
Para la comparación de tamaño, no hay problema con el uso>, <, <=,> =, y se unirán automáticamente. Pero generalmente recomendamos usar las siguientes dos formas de comparar los tamaños:
Llame al método xxxValue () para convertirlo en el tipo de datos básicos para la comparación. En la clase WRAPPER, el método CompareTo () se reescribe. Al observar el código fuente CompareTo (), puede ver que, de hecho, el uso subyacente también se convierte en el tipo de datos básicos correspondientes al unboxing automáticamente y luego comparándolo.
2. Comparación de objetos Java
Con la introducción anterior, es más fácil comparar objetos. Los principios son los mismos.
1. Comparación de tipos de cadenas
Cabe señalar que el tipo de cadena no se puede usar directamente>, <=,> =, y <, e informará una excepción de compilación.
Paquete DailyTest; import org.junit.test;/*** Resumen comparativo en java* @author yrr*/public class javacomparetest {@test public void test03 () {String s1 = new String ("123"); Cadena s2 = nueva cadena ("123"); System.out.println (S1 == S2); // falso sistema.out.println (s1.equals (s2)); Cadena s3 = "234"; Cadena s4 = "234"; System.out.println (S3 == S4); // true System.out.println (S3.Equals (S4)); // true //system.out.println(s1 <= s3); // El operador <está indefinido para el tipo de argumento (s) java.lang.string, java.lang.string sistema.out.println (s1.compareto (S3) <0); //verdadero }}2. Comparación de objetos de clase
La conclusión de los objetos de clase es la misma, pero en comparación con los tipos de datos básicos y los tipos de cadenas, es un poco más complicado.
De acuerdo con una determinada regla, para determinar si los dos objetos son iguales, el método igual () debe reescribirse en la clase juzgada. El código de ejemplo es el siguiente:
Paquete DailyTest; import org.junit.test;/*** Resumen comparativo en java* @author yrr*/public class javacomparetest {@test public void test04 () {persona p1 = nueva persona ("yrr", 18); Persona P2 = nueva persona ("YRR", 18); System.out.println (P1 == P2); // falso sistema.out.println (p2.equals (p1)); // true}} persona de clase {nombre de cadena privada; edad de entero privado; Public Person () {} Public Person (nombre de cadena, edad entera) {this.name = name; this.age = edad; } public String getName () {nombre de retorno; } public Integer GetAge () {return Age; } @Override public boolean iguales (object obj) {persona persona = (persona) obj; return name.equals (persona.getName ()) && age.equals (persona.getage ()); }}Y si desea comparar los tamaños de dos objetos (esta también es una pregunta de entrevista común), hay dos maneras:
La clase comparable implementa la interfaz comparable y anula el método CompareTo () para definir la clase que implementa una interfaz comparadora o usa la clase interna para anular el método compare (): el primero se define en la clase comparable, mientras que la segunda se define fuera de la clase comparable. A través de esta diferencia, las ventajas y desventajas de los dos también son obvias. El primero es simple, pero requiere modificación de la clase comparada, mientras que la segunda no necesita modificar el código original, que es más flexible.
El primer método, el código de muestra es el siguiente:
Paquete DailyTest; import org.junit.test;/*** Resumen comparativo en java* @author yrr*/public class javacomparetest {@test public void test5 () {persona p1 = nueva persona ("yrr", 18); Persona p2 = nueva persona ("wx", 19); System.out.println (P1.compareto (P2) <0); }} Persona de clase implementa comparable <Oll> {Nombre de cadena privada; edad de entero privado; Public Person () {} Public Person (nombre de cadena, edad entera) {this.name = name; this.age = edad; } public Integer GetAge () {return Age; } @Override public int Compareto (persona o) {return this.getage () - o.getage (); }}El segundo método, el código de muestra es el siguiente:
Comparador de paquetes; import java.util.arrays; import java.util.comparator; public class MyComparator {public static void main (string [] args) {user [] users = new User [] {new User ("U1001", 25), New User ("U1002", 20), New User ("U1003", 21)}; Arrays.sort (usuarios, nuevo comparador <serem> () {@Override public int Compare (User O1, User O2) {return o1.getage () - o2.getage ();}}); for (int i = 0; i <users.length; i ++) {user user = users [i]; System.out.println (user.getID () + "" + user.getage ()); }}} User de clase {ID de cadena privada; edad privada int; Usuario público (ID de cadena, int Age) {this.id = id; this.age = edad; } public int getAge () {return Age; } public void setAge (int Age) {this.age = edad; } public String getId () {return id; } public void setid (ID de cadena) {this.id = id; }}Lo anterior es el contenido relevante de las preguntas de comparación de Java que le he dicho esta vez. Si tiene otras preguntas, puede discutirlas en el área de comentarios a continuación. Gracias por su apoyo.