Prueba 1:
Primero veamos un conjunto de comparaciones de tipo de cadena. Sin más ADO, solo ingrese el código:
Prueba de clase pública {public static void main (string [] args) {String a = "Java Book Garden"; Cadena b = "Jardín de libros Java"; Cadena c = nueva cadena ("Java Book Garden"); Cadena d = nueva cadena ("Java Book Garden"). Intern (); if (a == b) {system.out.println ("a == b"); } else {System.out.println ("A! = B"); } if (a.equals (b)) {system.out.println ("a.equals (b)"); } else {System.out.println ("! A.Equals (b)"); } if (a == c) {system.out.println ("a == c"); } else {system.out.println ("a! = c"); } if (a.equals (c)) {system.out.println ("a.equals (c)"); } else {System.out.println ("! A.Equals (c)"); } if (a == d) {system.out.println ("a == d"); } else {system.out.println ("a! = d"); } if (a.equals (d)) {system.out.println ("a.equals (d)"); } else {System.out.println ("A.Equals (d)"); }}}Resultado de salida:
a == ba.equals (b) a! = ca.equals (c) a == da.equals (d)
Resumir:
Resultado A == B: Cuando el programa se esté ejecutando, creará un grupo de búfer de cadena. Cuando la cadena a = "Java Book Garden", "Java Book Garden" se coloca en la piscina de búfer de cuerda. Cuando la cadena B = "Java Book Garden" crea una cadena, el programa primero buscará objetos con el mismo valor en este grupo de búfer de cadena. Por lo tanto, cuando se crea B, el programa encuentra A con el mismo valor y hace referencia al objeto a la que se hace referencia a. Por lo tanto, A y B se refieren al mismo objeto, por lo que a == b.
Como resultado, a! = C: String C = New String ("Java Book Garden") nuevo un nuevo objeto, por lo que no se busca desde el grupo de búfer de cadena, y crea directamente un nuevo objeto. Entonces a! = C.
Resultado a == D: Cuando se llama el método interno, si el grupo ya contiene una cadena igual a este objeto de cadena (el objeto está determinado por el método igual (objeto)), se devuelve la cadena en el grupo. De lo contrario, agregue este objeto de cadena al grupo y devuelva una referencia a este objeto de cadena. Todos los D llaman objetos de a.
Equals compara los valores, por lo que cuando los valores son los mismos, son iguales.
Prueba 2:
Aquí hay una prueba de un conjunto de tipos de int y tipos enteros:
prueba de clase pública {public static void main (string [] args) {int a = 127; int a1 = 127; int b = 128; entero C = 127; Entero C1 = 127; Entero d = 128; Entero d1 = 128; if (a == a1) {system.out.println ("a == a1"); } else {system.out.println ("a! = a1"); } if (b == b1) {system.out.println ("b == b1"); } else {System.out.println ("B! = B1"); } if (c == c1) {system.out.println ("c == c1"); } else {System.out.println ("C! = C1"); } if (d == d1) {system.out.println ("d == d1"); } else {System.out.println ("d! = d1"); }}}Resultado de salida:
a == A1B == B1C == C1D! = D1
El resultado "a == a1" y "b == b1": int son tipos básicos, y los valores se almacenan directamente, mientras que el entero es un objeto y señala este objeto con una referencia. La mayoría de las comparaciones están hechas de "A == A1" y "B == B1".
Los resultados "C == C1" y "D! = D1" pueden tener preguntas aquí, por qué "d! = D1". Echemos un vistazo al código fuente de entero juntos.
/** * Cache para admitir la semántica de identidad de objetos del autoboxing para los valores entre * -128 y 127 (inclusive) según lo requerido por JLS. * * El caché se inicializa en el primer uso. El tamaño del caché * puede ser controlado por la opción -xx: autoboxcachemax = <size>. * Durante la inicialización de VM, java.lang.integer.integercache.high propiedad * puede establecerse y guardar en las propiedades del sistema privado en la clase * Sun.misc.vm. */ Clase estática privada IntegerCache {static final int low = -128; estático final int high; Cache entero final estático []; static {// El valor alto puede configurarse mediante la propiedad int h = 127; String IntegerCacheHighPropValue = Sun.Misc.Vm.GetSavedProperty ("java.lang.integer.integercache.high"); if (integerCacheHighPropValue! = NULL) {int i = parseInt (integerCacheHighPropValue); i = math.max (i, 127); // El tamaño máximo de la matriz es integer.max_value h = math.min (i, integer.max_value -(-low) -1); } high = h; caché = nuevo entero [(alto - bajo) + 1]; int j = bajo; para (int k = 0; k <cache.length; k ++) caché [k] = nuevo entero (j ++); } private integerCache () {}} /** * Devuelve una instancia {@code integer} que representa el valor especificado * {@code int}. Si no se requiere una nueva instancia {@code entero}, este método generalmente debe usarse con preferencia a * El constructor {@link #Integer (int)}, ya que es probable que este método * produzca un rendimiento de espacio y tiempo significativamente mejor al * almacenamiento de valores frecuentemente solicitados con frecuencia. * * Este método siempre almacenará en caché los valores en el rango -128 a 127, * inclusive, y puede almacenar en caché otros valores fuera de este rango. * * @param i an {@code int} valor. * @return una instancia {@code entero} que representa {@code i}. * @since 1.5 */ public static entero Value de (int i) {afirmar integerCache.high> = 127; if (i> = integerCache.low && i <= integerCache.high) return integerCache.cache [i + (-intgerCache.low)]; devolver nuevo entero (i); }Conclusión: Aquí entero inicializará un grupo constante de [-128,127]. Si el valor está en este rango, se hace referencia al mismo objeto. Si no está en este rango, se puede ver desde el código fuente que el nuevo objeto devuelto es: devolver nuevo entero (i);
Por lo tanto, el resultado "C == C1" se refiere al mismo objeto, y el resultado "D! = D1" se refiere a un nuevo objeto nuevo, por lo que es diferente.