Problemas comparativos em Java são muito básicos e fáceis de confundir. Hoje vou resumir e organizar um resumo e arranjo mais detalhados de alguns pontos propensos a erros, esperando que seja útil para estudos e entrevistas de todos.
1. A diferença entre == e igual ()
Primeiro de tudo, precisamos saber a diferença entre == e igual (). O sinal == é sempre comparado com o valor do endereço. Para tipos básicos de dados, == Comparação é realmente se os valores da variável são iguais, enquanto para os tipos de dados de referência, o valor do endereço é comparado. O que você precisa para prestar atenção especial aqui é o tipo de string, que é fácil de dar como certo == e é fácil de cometer erros. O método iguals () é um método na classe de objeto. Sabemos que todas as classes em Java herdarão a classe de objeto por padrão, para que os objetos da classe tenham o método iguals (). O método iguals () na classe de objeto é mostrado na figura abaixo:
Como pode ser visto no código -fonte, a camada subjacente do método iguals () na classe de objeto também usa ==, então é realmente o valor do endereço. Portanto, se queremos usar o método Equals () para outras comparações, precisamos substituir o método iguals ().
2. Tipos de dados básicos e tipos de embalagem
Todos sabemos que byte, curto, int, longo, booleano, char, dupla e flutuação são tipos de dados básicos, e as variáveis que eles declaram são armazenadas na memória da pilha. As variáveis definidas por seus tipos de embalagem correspondentes (byte, curto, inteiro, longo, booleano, caráter, duplo) existem na memória da heap. Para tipos básicos de dados, sua comparação é relativamente simples, ou seja, use == para determinar se são iguais e usam <,>, <=,> = para comparar tamanhos. Mas para tipos de embalagem, é um pouco diferente.
Primeiro, para determinar se é igual, consulte o resultado da execução do seguinte código:
pacote DailyTest; importar org.junit.test;/*** Resumo comparativo em java* @author yrr*/public class JavacomPareTest {/*** Julgamento do tipo inteiro é igual*/@test public void test01 () {int n3 = 48; System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- N8); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.Println (N1.IntValue () == N2.IntValue (); // true system.out.println (n4.equals (n5)); * O julgamento do tipo longo é igual */@test public void test02 () {// Observe aqui que, ao usar uma definição longa, L ou L não é necessário, mas ao usar longo, caso contrário, um erro será relatado // adicione -o na construção para indicar a diferença longa n3 = 48L; System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Println (N1 == N2); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.It.println (n4 == n5); O método Long.IntValue (), você precisa prestar atenção para verificar se é nulo para impedir o NullPointException}}Para os resultados da execução acima, é feita a seguinte explicação:
Primeiro, para o novo método, declaramos um número inteiro ou um objeto longo. Como o novo objeto abre uma peça de espaço na pilha, mesmo que os valores dos dois sejam os mesmos, para ==, o valor do endereço for comparado, portanto, False será retornado. Para as classes de wrapper de tipos de dados básicos, o método Equals () foi reescrito e o tamanho numérico será comparado; portanto, o método iguals () pode ser usado para julgar com base no tamanho numérico. Em relação ao problema de comparar variáveis inteiras com variáveis int, descobriremos que o valor de comparação também é baseado no tamanho numérico. Isso ocorre porque, ao comparar, o tipo inteiro é automaticamente não caixa e convertido no tipo int. A explicação dos três primeiros pontos é aplicável a todos os tipos de embalagem. Para o método de atribuição direta, as duas variáveis inteiras com um valor de 48 são consideradas verdadeiras pelo sinal ==, mas quando o valor é 128, é falso. Isso ocorre porque na parte inferior, para o número inteiro n1 = 48;, o método de atribuição direta realmente chama o método integer.value (). Podemos dar uma breve olhada no código -fonte do método integer.value (), conforme mostrado na figura abaixo:
Podemos ver que existe um julgamento se aqui. Quando a entrada I está dentro do intervalo de [-128, 127], ela é retornada diretamente da matriz Integercache. Portanto, para valores nesse intervalo, os valores de endereço correspondentes a essa matriz são retornados; portanto, o uso do sinal == para julgar true será retornado. O que não está dentro desse intervalo é o objeto que é novo, portanto, False será retornado. Esta conclusão é verdadeira para tipos de byte, curto, inteiro e longo (se você estiver interessado, pode verificar o código-fonte do método de valor () correspondente ()), porque o escopo do tipo de byte é [-128, 127], portanto, para o tipo de byte, usando == não é diferente de equals ().
Para comparação de tamanho, não há problema em usar>, <, <=,> =, e eles serão automaticamente desbotados. Mas geralmente recomendamos o uso das duas maneiras a seguir para comparar tamanhos:
Ligue para o método xxxvalue () para convertê -lo no tipo de dados básico para comparação. Na classe Wrapper, o método compareto () é reescrito. Observando o código -fonte CompareTo (), você pode ver que, de fato, o uso subjacente também é convertido no tipo de dados básico correspondente por desbaste automaticamente e comparando -o.
2. Comparação de objetos Java
Com a introdução acima, é mais fácil comparar objetos. Os princípios são os mesmos.
1. Comparação de tipos de string
Deve -se notar que o tipo de sequência não pode ser usado diretamente>, <=,> = e <, e relatará uma exceção de compilação.
pacote DailyTest; importar org.junit.test;/*** Resumo comparativo em java* @author yrr*/public class JavacomParetest {@Test public void test03 () {string s1 = new String ("123"); String S2 = new String ("123"); System.out.println (S1 == S2); // false System.out.println (S1.Equals (S2)); String s3 = "234"; String s4 = "234"; System.out.println (S3 == S4); // true system.out.println (s3.equals (s4)); // true //system.out.println(s1 <= s3); // O operador <é indefinido para o (s) tipo (s) de argumento (s) java.lang.string, java.lang.string System.out.println (s1.compareto (s3) <0); //verdadeiro }}2. Comparação de objetos de classe
A conclusão dos objetos de classe é a mesma, mas comparada aos tipos básicos de dados e tipos de string, é um pouco mais complicado.
De acordo com uma certa regra, para determinar se os dois objetos são iguais, o método iguals () precisa ser reescrito na classe julgada. O código de exemplo é o seguinte:
pacote DailyTest; importar org.junit.test;/*** Resumo comparativo em java* @author yrr*/public class JavacomParetest {@Test public void test04 () {Pessoa P1 = nova pessoa ("Yrr", 18); Pessoa P2 = Nova pessoa ("Yrr", 18); System.out.println (p1 == p2); // false System.out.println (p2.equals (p1)); // true}} classe PERSON {private String Name; idade inteira privada; public Person () {} public Person (nome da string, idade inteira) {this.name = name; this.age = idade; } public string getName () {return name; } public integer getage () {retorna idade; } @Override public boolean igual (objeto obj) {pessoa pessoa = (pessoa) obj; retornar name.equals (PERSON.GETNAME ()) && Age.Equals (PERSON.GETAGE ()); }}E se você deseja comparar os tamanhos de dois objetos (esta também é uma pergunta comum da entrevista), existem duas maneiras:
A classe comparável implementa a interface comparável e substitui o método compareto () para definir a classe que implementa uma interface do comparador ou use a classe interna para substituir o método compare (): o primeiro é definido na classe comparável, enquanto a última é definida fora da classe comparável. Com essa diferença, as vantagens e desvantagens dos dois também são óbvias. O primeiro é simples, mas requer modificação da classe comparada, enquanto a última não precisa modificar o código original, o que é mais flexível.
O primeiro método, o código de amostra é o seguinte:
pacote DailyTest; importar org.junit.test;/*** Resumo comparativo em java* @author yrr*/public class JavacomParetest {@Test public void test5 () {Pessoa P1 = nova pessoa ("Yrr", 18); Pessoa P2 = nova pessoa ("WX", 19); System.out.println (p1.compareto (p2) <0); }} classe Pessoa implementa comparável a <Pesso> {nome da string privada; idade inteira privada; public Person () {} public Person (nome da string, idade inteira) {this.name = name; this.age = idade; } public integer getage () {retorna idade; } @Override public int compareto (pessoa o) {return this.getage () - o.getage (); }}O segundo método, o código de amostra é o seguinte:
package comparator;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 (usuários, novo comparador <suser> () {@Override public int Compare (Usuário O1, Usuário O2) {return o1.getage () - o2.getage ();}}); for (int i = 0; i <users.length; i ++) {user user = usuários [i]; System.out.println (user.getId () + "" + user.getage ()); }}} classe de usuário {private string ID; private Int Age; Usuário público (ID da String, Int Age) {this.id = id; this.age = idade; } public int getage () {Age de retorno; } public void setage (int Age) {this.age = Age; } public string getId () {return id; } public void setId (string id) {this.id = id; }}O exposto acima é o conteúdo relevante das perguntas de comparação de Java que eu lhe contei desta vez. Se você tiver outras perguntas, poderá discuti -las na área de comentários abaixo. Obrigado pelo seu apoio.