Quanti spazi rimuoverà Java String.trim ()?

In Java, ho una stringa come questa:

"     content     ".

Sarà String.trim()rimuovere tutti gli spazi su questi lati o solo uno spazio su ogni?

Tutti loro .

Restituisce : una copia di questa stringa con lo spazio bianco iniziale e finale rimosso, o questa stringa se non ha spazi bianchi iniziali o finali.

~ Citato dai documenti Java 1.5.0

(Ma perché non l'hai semplicemente provato e visto di persona?)

Dal codice sorgente (decompilato):

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

I due whileche puoi vedere significano che tutti i caratteri il cui unicode è sotto lo spazio, all'inizio e alla fine, vengono rimossi.

In caso di dubbio, scrivi uno unit test:

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

NB : ovviamente il test (per JUnit + Hamcrest) non fallisce

Una cosa da sottolineare, tuttavia, è che String.trim ha una definizione particolare di "spazi bianchi". Non rimuove gli spazi bianchi Unicode, ma rimuove anche i caratteri di controllo ASCII che potresti non considerare spazi bianchi.

Questo metodo può essere utilizzato per tagliare gli spazi all'inizio e alla fine di una stringa; infatti, taglia anche tutti i caratteri di controllo ASCII.

Se possibile, potresti voler usare StringUtils.strip () di Commons Lang, che gestisce anche gli spazi bianchi Unicode (ed è anche null-safe).

Vedi API per la classe String:

Restituisce una copia della stringa, omettendo gli spazi iniziali e finali.

Lo spazio bianco su entrambi i lati viene rimosso:

Nota che trim()non cambia l'istanza String, restituirà un nuovo oggetto:

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

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

Sulla base dei documenti Java qui , .trim()sostituisce "\ u0020", comunemente noto come spazi bianchi.

Ma prendi nota, "\ u00A0" ( Unicode NO-BREAK SPACE   ) è visto anche come uno spazio bianco e .trim()NON lo rimuoverà. Questo è particolarmente comune in HTML.

Per rimuoverlo, utilizzo:

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

Un esempio di questo problema è stato discusso qui .

Esempio di Java che trim()rimuove gli spazi:

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

PRODUZIONE

old = 
 This is a String.


new = This is a String.

Da java docs (sorgente 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;
}

Si noti che dopo aver ottenuto inizio e lunghezza chiama il metodo della sottostringa della classe String.

trim()rimuoverà tutti gli spazi iniziali e finali. Ma attenzione: la tua stringa non è cambiata. trim()restituirà invece una nuova istanza di stringa.

Se il tuo input String è:

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

Sì, l'output sarà "abc"; Ma se il tuo input String è:

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

L'output sarà This is a test Quindi trim rimuove solo gli spazi prima del primo carattere e dopo l'ultimo carattere nella stringa e ignora gli spazi interni. Questo è un pezzo del mio codice che ottimizza leggermente il Stringmetodo di taglio incorporato rimuovendo gli spazi interni e rimuove gli spazi prima e dopo il tuo primo e ultimo carattere nella stringa. Spero che sia d'aiuto.

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

Rimuoverà tutti gli spazi su entrambi i lati.

Una cosa molto importante è che una stringa composta interamente da "spazi bianchi" restituirà una stringa vuota.

se a string sSomething = "xxxxx", dove xsta per spazi bianchi, sSomething.trim()restituirà una stringa vuota.

se a string sSomething = "xxAxx", dove xsta per spazi bianchi, sSomething.trim()tornerà A.

se sSomething ="xxSomethingxxxxAndSomethingxElsexxx", sSomething.trim()tornerà SomethingxxxxAndSomethingxElse, nota che il numero di xparole tra le parole non è alterato.

Se vuoi che una stringa ordinata in pacchetti si combini trim()con regex come mostrato in questo post: Come rimuovere gli spazi bianchi duplicati nella stringa usando Java? .

L'ordine non ha senso per il risultato, ma trim()prima sarebbe più efficiente. Spero che sia d'aiuto.

Per mantenere solo un'istanza per la stringa, è possibile utilizzare quanto segue.

str = "  Hello   ";

o

str = str.trim();

Quindi il valore della strstringa saràstr = "Hello"

Trim () funziona per entrambi i lati.

Javadoc per String ha tutti i dettagli. Rimuove lo spazio bianco (spazio, tabulazioni, ecc.) Da entrambe le estremità e restituisce una nuova stringa.

Se vuoi controllare cosa farà qualche metodo, puoi usare BeanShell . È un linguaggio di scripting progettato per essere il più vicino possibile a Java. In generale viene interpretato Java con qualche rilassamento. Un'altra opzione di questo tipo è il linguaggio Groovy . Entrambi questi linguaggi di scripting forniscono un comodo loop Read-Eval-Print conosciuto dai linguaggi interpretati. Quindi puoi eseguire la console e digitare semplicemente:

"     content     ".trim();

Vedrai "content"come risultato dopo aver premuto Enter(o Ctrl+Rnella console Groovy).

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