Java "igual" e "==" semelhanças
Primeiro, vamos falar brevemente sobre "igual" e "=="
== Operação compara se os valores das duas variáveis são iguais para o tipo de dados básico.
Para variáveis de referência, significa se os endereços armazenados na pilha são os mesmos,
O conteúdo da pilha é o mesmo?
Se as duas variáveis representadas pela operação igual são referências ao mesmo objeto,
Ou seja, se o conteúdo na pilha é o mesmo.
Em resumo, == compara os endereços de 2 objetos, enquanto igual a igual ao conteúdo de 2 objetos.
Deixe -me apresentar brevemente a classe String
A classe String também é chamada de sequência de caracteres imutável
A String usa o valor final de char final privado [] para realizar o armazenamento de strings. Ou seja, depois que o objeto String for criado, o conteúdo da string armazenado neste objeto não pode ser modificado. A classe String possui um método de criação especial, que deve usar "" citações duplas para criá -lo. Por exemplo, a nova string ("123") realmente cria 2 objetos de string, um é criado por "123" através de "" aspas duplas, e o outro é criado pela New. No entanto, os períodos que eles criam são diferentes, um é o período de compilação e o outro é o período de execução. Java sobrecarrega o operador + para o tipo de string e você pode usar diretamente + para concatenar duas strings. Chamar o método intern () da classe String durante o tempo de execução pode adicionar dinamicamente objetos ao pool de string.
Diferencie entre dois métodos de criação de objetos de string "" e novo ()
String é um dados de embalagem especial. Pode ser usado:
String str1 = new String ("123"); String str2 = "123";Crie dois formulários
O primeiro é usar o novo () para criar um novo objeto, que será armazenado na pilha. Um novo objeto é criado toda vez que é chamado. (Na verdade, são dois, como mencionado acima, mas após a existência de "123" no pool constante, o novo "123" não será mais criado no pool constante)
O segundo tipo é primeiro criar uma variável STR para o objeto da classe String na pilha e depois usar referência simbólica para descobrir se existe "ABC" no pool constante de string. Caso contrário, armazene "ABC" no pool constante de cordas e deixe o STR apontar para "ABC". Se já houver "ABC", deixe o STR apontar diretamente para "ABC".
Devemos prestar atenção neste momento
Por um lado, o primeiro método de escrita é benéfico e salva o espaço da memória. Ao mesmo tempo, pode melhorar a velocidade de execução do programa até certo ponto, porque a JVM decidirá automaticamente se é necessário criar um novo objeto com base na situação real dos dados na pilha. Para o código da string str = new String ("123");, novos objetos são criados na pilha, independentemente de os valores da string serem iguais ou não, seja necessário criar novos objetos, aumentando assim a carga do programa. Por outro lado, quando definimos uma classe usando um formato como String str = "123";, sempre tomamos como certo que criamos um objeto STR da classe String.
O objeto pode não ter sido criado! E talvez apenas aponte para um objeto que foi criado anteriormente. Somente através do método novo () podemos garantir que um novo objeto seja criado sempre.
Por favor, veja o seguinte exemplo
pacote teststring; classe pública testString {public static void main (string [] args) {string a = "123"; String b = "123"; System.out.println (a == b); System.out.println (A.Equals (b)); System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And O conteúdo dos dois objetos referenciados no heap é o mesmo, então a.quals (b) é verdadeira */ string c = new String ("1234"); System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- But c is O mesmo que D Heap, então C.Equals (D) é verdadeiro */ String E = "A1"; String f = "a" +1; System.out.println (e == f); System.out.println (E.Equals (f)); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * Sim, o próprio Java possui uma sobrecarga do operador, mas você não pode usar a sobrecarga do operador que se define "H"; System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!