Melhora de sintaxe das descrições e código. (#25652)

guide/portuguese/java/strings/index.md

@@ -24,17 +24,17 @@ Você pode criar um objeto String das seguintes maneiras:
 
 Você pode estar pensando: qual é a diferença entre os três?
 
-Bem, o uso da `new` palavra-chave 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 coloca-os 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.
+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.
 
 Nesse trecho de código, quantos objetos String são criados?
 
 ```java
 String str = "This is a string"; 
- String str2 = "This is a string"; 
- String str3 = new String("This is a string"); 
+String str2 = "This is a string"; 
+String str3 = new String("This is a string"); 
 ```
 
-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çadas a criação de um novo objeto distinto.
+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.
 
@@ -42,15 +42,14 @@ Você pode testar isso usando a andorinha, a comparação rápida de objetos `==
 
 ```java
 System.out.println(str == str2); // This prints 'true' 
- System.out.println(str == str3); // This prints 'false' 
- System.out.println(str.equals(str3)); // This prints 'true' 
+System.out.println(str == str3); // This prints 'false' 
+System.out.println(str.equals(str3)); // This prints 'true' 
 ```
 
 Aqui está outro exemplo de como criar uma string em Java usando os diferentes métodos:
 
 ```java
-public class StringExample{ 
- 
+public class StringExample{
    public static void main(String args[]) { 
       String s1 = "java";  // creating string by Java string literal 
       char ch[] = {'s','t','r','i','n','g','s'}; 
@@ -75,10 +74,10 @@ Retorna true se dois objetos são iguais e false caso contrário.
 
 ```java
 String str = "Hello world"; 
- String str2 = "Hello world"; 
- 
- System.out.println(str == str2); // This prints false 
- System.out.println(str.equals(str2); // This prints true 
+String str2 = "Hello world"; 
+
+System.out.println(str == str2); // This prints false 
+System.out.println(str.equals(str2); // This prints true 
 ```
 
 A primeira comparação é falsa porque "==" analisa as referências e elas não são as mesmas.
@@ -89,7 +88,6 @@ Temos vários métodos internos em String. A seguir, um exemplo do método Strin
 
 ```java
 public class StringDemo { 
- 
    public static void main(String args[]) { 
       String palindrome = "Dot saw I was Tod"; 
       int len = palindrome.length(); 
@@ -114,7 +112,7 @@ O "comprimento" de uma string é apenas o número de caracteres nela. Então, "h
 
 ```java
 String a = "Hello"; 
- int len = a.length();  // len is 5 
+int len = a.length();  // len is 5 
 ```
 
 #### Outros métodos de comparação que também podem ser usados ​​na String são:
@@ -123,18 +121,17 @@ String a = "Hello";
 
 ```java
 String a = "HELLO"; 
- String b = "hello"; 
- System.out.println(a.equalsIgnoreCase(b));   // It will print true 
+String b = "hello"; 
+System.out.println(a.equalsIgnoreCase(b));   // It will print true 
 ```
 
 2.  compareTo: - compara o valor lexicograficamente e retorna um inteiro.
 
 ```java
 String a = "Sam"; 
- String b = "Sam"; 
- String c = "Ram"; 
- System.out.println(a.compareTo(b));       // 0 
- System.out.prinltn(a.compareTo(c));       // 1 since (a>b) 
- System.out.println(c.compareTo(a));       // -1 since (c<a) 
-
-```
+String b = "Sam"; 
+String c = "Ram"; 
+System.out.println(a.compareTo(b));       // 0 
+System.out.prinltn(a.compareTo(c));       // 1 since (a>b) 
+System.out.println(c.compareTo(a));       // -1 since (c<a) 
+```