¿Cuántos espacios eliminará Java String.trim ()?

En Java, tengo una cadena como esta:

"     content     ".

¿ String.trim()Eliminará todos los espacios en estos lados o solo un espacio en cada uno?

Todos ellos .

Devuelve : una copia de esta cadena con espacios en blanco iniciales y finales eliminados, o esta cadena si no tiene espacios en blanco iniciales o finales.

~ Citado de documentos de Java 1.5.0

(¿Pero por qué no lo probaste y lo viste por ti mismo?)

Del código fuente (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);
  }

Los dos whileque puede ver significan que se eliminan todos los caracteres cuyo Unicode está debajo del carácter de espacio, al principio y al final.

En caso de duda, escriba una prueba unitaria:

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

NB : por supuesto, la prueba (para JUnit + Hamcrest) no falla

Sin embargo, una cosa a señalar es que String.trim tiene una definición peculiar de "espacio en blanco". No elimina los espacios en blanco Unicode, pero también elimina los caracteres de control ASCII que no puede considerar espacios en blanco.

Este método se puede utilizar para recortar los espacios en blanco desde el principio y el final de una cadena; de hecho, también recorta todos los caracteres de control ASCII.

Si es posible, es posible que desee utilizar StringUtils.strip () de Commons Lang, que también maneja los espacios en blanco Unicode (y también es seguro para nulos).

Ver API para la clase String:

Devuelve una copia de la cadena, omitiendo los espacios en blanco iniciales y finales.

Se eliminan los espacios en blanco en ambos lados:

Tenga en cuenta que trim()no cambia la instancia de String, devolverá un nuevo objeto:

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

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

Según los documentos de Java aquí , .trim()reemplaza '\ u0020', que se conoce comúnmente como espacios en blanco.

Pero tenga en cuenta, el '\ u00A0' ( Unicode NO-BREAK SPACE   ) también se ve como un espacio en blanco y .trim()NO lo eliminará. Esto es especialmente común en HTML.

Para eliminarlo, uso:

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

Aquí se analizó un ejemplo de este problema .

Ejemplo de Java trim()eliminando espacios:

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);
    }
}

SALIDA

old = 
 This is a String.


new = This is a String.

De java docs (fuente de clase 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;
}

Tenga en cuenta que después de obtener el inicio y la duración, llama al método de subcadena de la clase String.

trim()eliminará todos los espacios en blanco iniciales y finales. Pero tenga en cuenta: su cadena no ha cambiado. trim()devolverá una nueva instancia de cadena en su lugar.

Si su entrada de cadena es:

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

Sí, la salida será "abc"; Pero si su entrada de cadena es:

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

La salida será This is a test Entonces, recortar solo elimina los espacios antes de su primer carácter y después de su último carácter en la cadena e ignora los espacios internos. Esta es una parte de mi código que optimiza ligeramente el Stringmétodo de recorte incorporado eliminando los espacios internos y elimina los espacios antes y después de su primer y último carácter en la cadena. Espero eso ayude.

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);
  }

Eliminará todos los espacios en ambos lados.

Una cosa muy importante es que una cadena hecha completamente de "espacios en blanco" devolverá una cadena vacía.

si a string sSomething = "xxxxx", donde xrepresentan espacios en blanco, sSomething.trim()devolverá una cadena vacía.

si a string sSomething = "xxAxx", donde xrepresentan espacios en blanco, sSomething.trim()volveráA .

Si sSomething ="xxSomethingxxxxAndSomethingxElsexxx", sSomething.trim()va a volver SomethingxxxxAndSomethingxElse, el aviso de que el número de xentre las palabras no se altera.

Si desea una cadena ordenada empaquetada, combine trim()con expresiones regulares como se muestra en esta publicación: ¿Cómo eliminar espacios en blanco duplicados en una cadena usando Java? .

El orden no tiene sentido para el resultado, pero trim()primero sería más eficiente. Espero eso ayude.

Para mantener solo una instancia para la Cadena, puede usar lo siguiente.

str = "  Hello   ";

o

str = str.trim();

Entonces el valor de la strCadena serástr = "Hello"

Trim () funciona para ambos lados.

Javadoc para String tiene todos los detalles. Elimina los espacios en blanco (espacio, tabulaciones, etc.) de ambos extremos y devuelve una nueva cadena.

Si desea comprobar qué hará algún método, puede utilizar BeanShell . Es un lenguaje de scripting diseñado para estar lo más cerca posible de Java. Generalmente hablando se interpreta Java con algunas relajaciones. Otra opción de este tipo es el lenguaje Groovy . Ambos lenguajes de secuencias de comandos proporcionan un conveniente bucle de lectura-evaluación-impresión a partir de lenguajes interpretados. Entonces puede ejecutar la consola y simplemente escribir:

"     content     ".trim();

Verá "content"como resultado después de presionar Enter(o Ctrl+Ren la consola Groovy).

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