Teste 1:
Vamos primeiro olhar para um conjunto de comparações de tipo de string. Sem mais delongas, basta inserir o código:
classe pública teste {public static void main (string [] args) {string a = "Java Book Garden"; String b = "Java Livro Jardim"; String c = new String ("Java Book Garden"); String d = new String ("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 da saída:
a == ba.equals (b) a! = ca.equals (c) a == da.equals (d)
Resumir:
Resultado A == B: Quando o programa estiver em execução, ele criará um pool de buffer de string. Quando a string a = "Java Book Garden", "Java Book Garden" é colocado no pool de buffer de cordas. Quando a string b = "Java Book Garden" cria uma string, o programa procurará primeiro objetos com o mesmo valor neste pool de buffer de string. Portanto, quando B é criado, o programa encontra um com o mesmo valor e faz referência ao objeto referenciado por a. Portanto, A e B se referem ao mesmo objeto, então a == b.
Como resultado, a! = C: string c = new string ("Java Book Garden") novo um novo objeto, para que não seja pesquisado no pool de buffer de string e cria diretamente um novo objeto. Então a! = C.
Resultado A == D: Quando o método do estagiário é chamado, se o pool já contiver uma sequência igual a esse objeto String (o objeto é determinado pelo método igual (objeto)), a sequência no pool é retornada. Caso contrário, adicione este objeto String ao pool e retorna uma referência a este objeto String. Todos d chamam objetos de a.
É igual a valores, portanto, quando os valores são iguais, eles são iguais.
Teste 2:
Aqui está um teste de um conjunto de tipos int e tipos inteiros:
classe pública teste {public static void main (string [] args) {int a = 127; int a1 = 127; int b = 128; número inteiro c = 127; Número inteiro c1 = 127; Número inteiro d = 128; Número inteiro 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 da saída:
a == a1b == b1c == c1d! = d1
O resultado "A == A1" e "B == B1": int são tipos básicos, e os valores são armazenados diretamente, enquanto o número inteiro é um objeto e aponta para esse objeto com uma referência. A maioria das comparações é feita de "A == A1" e "B == B1".
Os resultados "c == c1" e "d! = D1" podem ter perguntas aqui, por que "d! = D1". Vamos dar uma olhada no código -fonte do número inteiro juntos.
/** * Cache para suportar a semântica de identidade do objeto da auto -boxação para valores entre * -128 e 127 (inclusive) conforme exigido pelo JLS. * * O cache é inicializado no primeiro uso. O tamanho do cache * pode ser controlado pela opção -xx: autoboxcachemax = <tamanho>. * Durante a inicialização da VM, java.lang.integer.integercache.high Propriedade * pode ser definida e salva nas propriedades do sistema privado na classe * Sun.misc.vm. */ classe estática privada integercache {estático final int baixo = -128; estático final int alto; Cache inteiro final estático []; estático {// Alto valor pode ser configurado pela propriedade int h = 127; String integegercacheHighPropValue = Sun.misc.vm.getSavedProperty ("java.lang.integer.integercache.high"); if (integercacheHighPropValue! = null) {int i = parseint (integercacheHighPropValue); i = math.max (i, 127); // O tamanho máximo da matriz é inteiro.max_value h = math.min (i, integer.max_value -(-low) -1); } alta = h; cache = novo número inteiro [(alto - baixo) + 1]; int j = baixo; for (int k = 0; k <cache.length; k ++) cache [k] = novo número inteiro (j ++); } private integercache () {}} /** * Retorna uma instância {@code integer} representando o valor especificado * {@code int}. Se uma nova instância {@code integer} não for * necessária *, esse método geralmente deve ser usado em preferência a * o construtor {@link #Integer (int)}, pois esse método provavelmente * produzirá um desempenho de espaço e tempo significativamente melhor ao * armazenar em cache de valores solicitados frequentemente. * * Este método sempre cache os valores no intervalo -128 a 127, * inclusive, e pode armazenar em cache outros valores fora desse intervalo. * * @param i um {@code int} value. * @return um {@code Integer} Instância representando {@code i}. * @since 1.5 */ public static integer valueof (int i) {assert integercache.high> = 127; if (i> = Integercache.low && i <= Integercache.high) retorna Integercache.cache [i + (-integercache.low)]; devolver novo número inteiro (i); }Conclusão: Aqui o número inteiro inicializará um pool constante de [-128,127]. Se o valor estiver nesse intervalo, o mesmo objeto será referenciado. Se não estiver nesse intervalo, ele pode ser visto no código -fonte que o novo objeto retornado é: retornar novo inteiro (i);
Portanto, o resultado "c == c1" refere -se ao mesmo objeto e o resultado "d! = D1" refere -se a um novo objeto, por isso é diferente.