Quantos espaços Java String.trim () removerá?

Em Java, tenho uma String como esta:

"     content     ".

Irá String.trim()remover todos os espaços nesses lados ou apenas um espaço em cada um?

Todos eles .

Retorna : Uma cópia desta string com espaço em branco à esquerda e à direita removidos, ou esta string se ela não tiver nenhum espaço em branco à esquerda ou à direita.

~ Citado em documentos Java 1.5.0

(Mas por que você não experimentou e viu por si mesmo?)

Do código-fonte (descompilado):

  public String trim()
  {
    int i = this.count;
    int j = 0;
    int k = this.offset;
    char[] arrayOfChar = this.value;
    while ((j < i) && (arrayOfChar[(k + j)] <= ' '))
      ++j;
    while ((j < i) && (arrayOfChar[(k + i - 1)] <= ' '))
      --i;
    return (((j > 0) || (i < this.count)) ? substring(j, i) : this);
  }

Os dois whileque você pode ver significam que todos os caracteres cujo unicode está abaixo do caractere de espaço, no início e no final, são removidos.

Em caso de dúvida, escreva um teste de unidade:

@Test
public void trimRemoveAllBlanks(){
    assertThat("    content   ".trim(), is("content"));
}

NB : é claro que o teste (para JUnit + Hamcrest) não falha

Uma coisa a se destacar, entretanto, é que String.trim tem uma definição peculiar de "espaço em branco". Ele não remove os espaços em branco Unicode, mas também remove os caracteres de controle ASCII que você pode não considerar os espaços em branco.

Este método pode ser usado para cortar os espaços em branco do início e do final de uma string; na verdade, ele também corta todos os caracteres de controle ASCII.

Se possível, você pode usar StringUtils.strip () de Commons Lang, que também lida com espaços em branco Unicode (e também é null-safe).

Consulte API para a classe String:

Retorna uma cópia da string, com espaços em branco à esquerda e à direita omitidos.

Espaços em branco em ambos os lados são removidos:

Observe que trim()não altera a instância de String, ela retornará um novo objeto:

 String original = "  content  ";
 String withoutWhitespace = original.trim();

 // original still refers to "  content  "
 // and withoutWhitespace refers to "content"

Com base nos documentos Java aqui , o .trim()substitui '\ u0020' que é comumente conhecido como espaço em branco.

Mas preste atenção, o '\ u00A0' ( Unicode NO-BREAK SPACE   ) também é visto como um espaço em branco e .trim()NÃO o removerá. Isso é especialmente comum em HTML.

Para removê-lo, eu uso:

tmpTrimStr = tmpTrimStr.replaceAll("\\u00A0", "");

Um exemplo desse problema foi discutido aqui .

Exemplo de trim()remoção de espaços de Java :

public class Test
{
    public static void main(String[] args)
    {
        String str = "\n\t This is be trimmed.\n\n";

        String newStr = str.trim();     //removes newlines, tabs and spaces.

        System.out.println("old = " + str);
        System.out.println("new = " + newStr);
    }
}

RESULTADO

old = 
 This is a String.


new = This is a String.

De documentos java (fonte da classe String),

/**
 * Returns a copy of the string, with leading and trailing whitespace
 * omitted.
 * <p>
 * If this <code>String</code> object represents an empty character
 * sequence, or the first and last characters of character sequence
 * represented by this <code>String</code> object both have codes
 * greater than <code>'&#92;u0020'</code> (the space character), then a
 * reference to this <code>String</code> object is returned.
 * <p>
 * Otherwise, if there is no character with a code greater than
 * <code>'&#92;u0020'</code> in the string, then a new
 * <code>String</code> object representing an empty string is created
 * and returned.
 * <p>
 * Otherwise, let <i>k</i> be the index of the first character in the
 * string whose code is greater than <code>'&#92;u0020'</code>, and let
 * <i>m</i> be the index of the last character in the string whose code
 * is greater than <code>'&#92;u0020'</code>. A new <code>String</code>
 * object is created, representing the substring of this string that
 * begins with the character at index <i>k</i> and ends with the
 * character at index <i>m</i>-that is, the result of
 * <code>this.substring(<i>k</i>,&nbsp;<i>m</i>+1)</code>.
 * <p>
 * This method may be used to trim whitespace (as defined above) from
 * the beginning and end of a string.
 *
 * @return  A copy of this string with leading and trailing white
 *          space removed, or this string if it has no leading or
 *          trailing white space.
 */
public String trim() {
int len = count;
int st = 0;
int off = offset;      /* avoid getfield opcode */
char[] val = value;    /* avoid getfield opcode */

while ((st < len) && (val[off + st] <= ' ')) {
    st++;
}
while ((st < len) && (val[off + len - 1] <= ' ')) {
    len--;
}
return ((st > 0) || (len < count)) ? substring(st, len) : this;
}

Observe que, depois de obter o início e o comprimento, ele chama o método substring da classe String.

trim()irá remover todos os espaços em branco à esquerda e à direita. Mas esteja ciente: sua string não foi alterada. trim()irá retornar uma nova instância de string.

Se a sua entrada String for:

String a = "   abc   ";
System.out.println(a);

Sim, a saída será, "abc"; Mas se sua entrada String for:

String b = "    This  is  a  test  "
System.out.println(b);

A saída será This is a test So trim apenas remove os espaços antes do seu primeiro caractere e depois do seu último caractere na string e ignora os espaços internos. Este é um trecho do meu código que otimiza ligeiramente o Stringmétodo interno de corte removendo os espaços internos e remove os espaços antes e depois de seu primeiro e último caractere na string. Espero que ajude.

public static String trim(char [] input){
    char [] output = new char [input.length];
    int j=0;
    int jj=0;
    if(input[0] == ' ' )    {
        while(input[jj] == ' ') 
            jj++;       
    }
    for(int i=jj; i<input.length; i++){
      if(input[i] !=' ' || ( i==(input.length-1) && input[input.length-1] == ' ')){
        output[j]=input[i];
        j++;
      }
      else if (input[i+1]!=' '){
        output[j]=' ';
        j++;
      }      
    }
    char [] m = new char [j];
    int a=0;
    for(int i=0; i<m.length; i++){
      m[i]=output[a];
      a++;
    }
    return new String (m);
  }

Isso removerá todos os espaços em ambos os lados.

Uma coisa muito importante é que uma string feita inteiramente de "espaços em branco" retornará uma string vazia.

se a string sSomething = "xxxxx", onde xsignifica espaços em branco, sSomething.trim()retornará uma string vazia.

se a string sSomething = "xxAxx", onde xficar por espaços em branco, sSomething.trim()retornará A.

se sSomething ="xxSomethingxxxxAndSomethingxElsexxx", sSomething.trim()voltará SomethingxxxxAndSomethingxElse, observe que o número xentre as palavras não é alterado.

Se você quiser uma string empacotada limpa, combine trim()com regex como mostrado neste post: Como remover espaços em branco duplicados em uma string usando Java? .

A ordem não faz sentido para o resultado, mas trim()primeiro seria mais eficiente. Espero que ajude.

Para manter apenas uma instância da String, você pode usar o seguinte.

str = "  Hello   ";

ou

str = str.trim();

Então, o valor da strString, serástr = "Hello"

Trim () funciona para ambos os lados.

Javadoc for String contém todos os detalhes. Remove o espaço em branco (espaço, tabulações, etc.) de ambas as extremidades e retorna uma nova string.

Se você quiser verificar o que algum método fará, você pode usar o BeanShell . É uma linguagem de script projetada para ser o mais próximo possível do Java. De modo geral, é interpretado Java com alguns relaxamentos. Outra opção desse tipo é a linguagem Groovy . Ambas as linguagens de script fornecem um loop Read-Eval-Print conveniente conhecido por linguagens interpretadas. Então você pode executar o console e apenas digitar:

"     content     ".trim();

Você verá o "content"resultado após pressionar Enter(ou Ctrl+Rno console do Groovy).

String formattedStr=unformattedStr;
formattedStr=formattedStr.trim().replaceAll("\\s+", " ");