Strings são seqüências de caracteres. Em Java, uma `String` é um `Object` . As strings não devem ser confundidas com `char` pois os caracteres são literalmente 1 valor em vez de uma sequência de caracteres. Você ainda pode usar 1 valor dentro de uma String, no entanto, é preferível usar `char` quando você está verificando 1 caractere.
```java
String course = "FCC";
System.out.println(course instanceof Object);
```
Saída:
```
true
```
Você pode criar um objeto String das seguintes maneiras:
1.`String str = "I am a String"; //as a String literal`
2.`String str = "I am a " + "String"; //as a constant expression`
3.`String str = new String("I am a String"); //as a String Object using the constructor`
Você pode estar pensando: qual é a diferença entre os três?
Bem, o uso da palavra-chave `new` garante que um novo objeto `String` será criado e um novo local de memória será alocado no `Heap` memória [(clique aqui para saber mais)](https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html). Corda literais e constantes As expressões String são armazenadas em cache no momento da compilação. O compilador os coloca no conjunto literal de cadeias para evitar duplicatas e melhorar o consumo de memória. A alocação de objetos é cara e esse truque aumenta o desempenho enquanto instancia Strings. Se você usar o mesmo literal novamente, a JVM usa o mesmo objeto. Usar o contructor como acima é quase sempre uma escolha pior.
A resposta é: 2 objetos String são criados. `str` e `str2` referem-se ao mesmo objeto. `str3` tem o mesmo conteúdo, mas usando `new` força a criação de um novo objeto distinto.
Quando você cria um literal String, a JVM verifica internamente, o que é conhecido como o `String pool` , para ver se ele pode encontrar um semelhante (conteúdo sábio) Objeto String. Se encontrar, retorna a mesma referência. Caso contrário, basta ir em frente e cria um novo objeto String no pool para que a mesma verificação pode ser realizada no futuro.
Você pode testar isso usando a andorinha, a comparação rápida de objetos `==` e os `equals()` implementados.
```java
System.out.println(str == str2); // This prints 'true'
String s2 = new String(ch); // converting char array to string
String s3 = new String("example"); // creating Java string by new keyword
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
```
#### Comparando Cordas
Se você quiser comparar o valor de duas variáveis String, não será possível usar ==. Isso se deve ao fato de que isso vai comparar as referências das variáveis e não os valores que estão ligados a eles. Para comparar os valores armazenados das Strings, você usa o método igual a.
```java
boolean equals(Object obj)
```
Retorna true se dois objetos são iguais e false caso contrário.
A primeira comparação é falsa porque "==" analisa as referências e elas não são as mesmas.
A segunda comparação é verdadeira porque as variáveis armazenam os mesmos valores. Neste caso, "Olá mundo".
Temos vários métodos internos em String. A seguir, um exemplo do método String Length ().
```java
public class StringDemo {
public static void main(String args[]) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
System.out.println( "String Length is : " + len );
}
}
```
Isto irá resultar em - `String Length is : 17`
**A resposta é: 2** objetos String são criados. **Notas**
1. Os métodos de string usam índices baseados em zero, exceto pelo segundo argumento de `substring()` .
2. A classe String é final - seus métodos não podem ser substituídos.
3. Quando o literal String é encontrado pela JVM, ele é adicionado ao pool literal de string.
4. A classe string possui um `length()` nome de método `length()` , enquanto matrizes têm um comprimento de nomenclatura de atributo.
5. Em java, objetos string são imutáveis. Imutável significa simplesmente inalterável ou imutável. Uma vez criado o objeto string, seus dados ou estados não podem ser alterados, mas um novo objeto string é criado.
Comprimento da corda
O "comprimento" de uma string é apenas o número de caracteres nela. Então, "hi" é length 2 e "Hello" é length 5. O método length () em uma string retorna seu tamanho, assim:
