Wie viele Leerzeichen entfernt Java String.trim ()?

In Java habe ich einen String wie diesen:

"     content     ".

Werden String.trim()alle Leerzeichen auf diesen Seiten oder nur jeweils ein Leerzeichen entfernt?

Alle von ihnen .

Rückgabe : Eine Kopie dieser Zeichenfolge mit entferntem und nachfolgendem Leerzeichen oder diese Zeichenfolge, wenn kein führender oder nachfolgender Leerraum vorhanden ist.

~ Zitiert aus Java 1.5.0-Dokumenten

(Aber warum hast du es nicht einfach versucht und es selbst gesehen?)

Aus dem Quellcode (dekompiliert):

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

Die beiden whileZeichen, die Sie sehen können, bedeuten, dass alle Zeichen, deren Unicode am Anfang und am Ende unter dem Leerzeichen liegt, entfernt werden.

Schreiben Sie im Zweifelsfall einen Komponententest:

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

NB : Natürlich schlägt der Test (für JUnit + Hamcrest) nicht fehl

Eine Sache, die jedoch hervorgehoben werden muss, ist, dass String.trim eine eigenartige Definition von "Leerzeichen" hat. Es werden keine Unicode-Leerzeichen entfernt, aber auch ASCII-Steuerzeichen, die Sie möglicherweise nicht als Leerzeichen betrachten.

Diese Methode kann verwendet werden, um Leerzeichen vom Anfang und Ende eines Strings abzuschneiden. Tatsächlich werden auch alle ASCII-Steuerzeichen abgeschnitten.

Wenn möglich, möchten Sie möglicherweise StringUtils.strip () von Commons Lang verwenden, das auch Unicode-Leerzeichen verarbeitet (und auch null-sicher ist).

Siehe API für die String-Klasse:

Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachfolgende Leerzeichen weggelassen werden.

Leerzeichen auf beiden Seiten werden entfernt:

Beachten Sie, dass trim()die String-Instanz nicht geändert wird und ein neues Objekt zurückgegeben wird:

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

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

Auf der Grundlage der Java - Dokumentation hier , die .trim()ersetzt ‚\ u0020‘ , die gemeinhin als Leerzeichen bekannt ist.

Beachten Sie jedoch, dass das '\ u00A0' ( Unicode NO-BREAK SPACE   ) auch als Leerzeichen angesehen wird und .trim()dieses NICHT entfernt. Dies ist besonders häufig in HTML.

Um es zu entfernen, benutze ich:

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

Ein Beispiel für dieses Problem wurde hier diskutiert .

Beispiel für das trim()Entfernen von Leerzeichen durch 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);
    }
}

AUSGABE

old = 
 This is a String.


new = This is a String.

Aus Java-Dokumenten (String-Klassenquelle),

/**
 * 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;
}

Beachten Sie, dass nach dem Start und der Länge die Teilstring-Methode der String-Klasse aufgerufen wird.

trim()entfernt alle führenden und nachfolgenden Leerzeichen. Beachten Sie jedoch, dass Ihre Zeichenfolge nicht geändert wird. trim()gibt stattdessen eine neue Zeichenfolgeninstanz zurück.

Wenn Ihre String-Eingabe lautet:

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

Ja, die Ausgabe lautet "abc". Aber wenn Ihre String-Eingabe ist:

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

Die Ausgabe wird This is a test so sein. Trimmen entfernt also nur Leerzeichen vor Ihrem ersten Zeichen und nach Ihrem letzten Zeichen in der Zeichenfolge und ignoriert die inneren Leerzeichen. Dies ist ein Teil meines Codes, der die integrierte StringTrimmmethode zum Optimieren der inneren Leerzeichen und zum Entfernen von Leerzeichen vor und nach Ihrem ersten und letzten Zeichen in der Zeichenfolge leicht optimiert . Ich hoffe es hilft.

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

Es werden alle Leerzeichen auf beiden Seiten entfernt.

Eine sehr wichtige Sache ist, dass eine Zeichenfolge, die vollständig aus "Leerzeichen" besteht, eine leere Zeichenfolge zurückgibt.

Wenn a string sSomething = "xxxxx", wo xfür Leerzeichen stehen, sSomething.trim()wird eine leere Zeichenfolge zurückgegeben.

Wenn a string sSomething = "xxAxx", wo xfür Leerzeichen stehen, sSomething.trim()wird zurückkehren A.

Wenn sSomething ="xxSomethingxxxxAndSomethingxElsexxx", sSomething.trim()wird zurückgegeben SomethingxxxxAndSomethingxElse, beachten Sie, dass die Anzahl der xWörter nicht geändert wird.

Wenn Sie eine ordentlich verpackte Zeichenfolge trim()mit Regex kombinieren möchten, wie in diesem Beitrag gezeigt: Wie entferne ich doppelte Leerzeichen in der Zeichenfolge mit Java? .

Ordnung ist für das Ergebnis bedeutungslos, trim()wäre aber zunächst effizienter. Ich hoffe es hilft.

Um nur eine Instanz für den String zu behalten, können Sie Folgendes verwenden.

str = "  Hello   ";

oder

str = str.trim();

Dann ist der Wert des strStringsstr = "Hello"

Trim () funktioniert für beide Seiten.

Javadoc for String enthält alle Details. Entfernt Leerzeichen (Leerzeichen, Tabulatoren usw.) von beiden Enden und gibt eine neue Zeichenfolge zurück.

Wenn Sie überprüfen möchten, was eine Methode bewirkt , können Sie BeanShell verwenden . Es ist eine Skriptsprache, die so nah wie möglich an Java ist. Im Allgemeinen wird Java mit einigen Entspannungen interpretiert. Eine weitere Option dieser Art ist die Groovy- Sprache. Beide Skriptsprachen bieten eine praktische Read-Eval-Print-Schleife, die aus interpretierten Sprachen bekannt ist. Sie können also die Konsole ausführen und einfach Folgendes eingeben:

"     content     ".trim();

Sie sehen dies "content"als Ergebnis nach dem Drücken Enter(oder Ctrl+Rin der Groovy-Konsole).

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