Java wie man zwei oder mehr Leerzeichen durch ein Leerzeichen in einer Zeichenfolge ersetzt und führende und nachfolgende Leerzeichen löscht

Versuche dies:

String after = before.trim().replaceAll(" +", " ");

Siehe auch

• String.trim()
  • Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachgestellte Leerzeichen weggelassen werden.
• regular-expressions.info/Repetition

Keine trim() Regex

Es ist auch möglich, dies mit nur einer replaceAll durchzuführen, dies ist jedoch weniger lesbar als die trim()-Lösung. Trotzdem wird hier nur gezeigt, was Regex tun kann:

    String[] tests = {
        "  x  ",          // [x]
        "  1   2   3  ",  // [1 2 3]
        "",               // []
        "   ",            // []
    };
    for (String test : tests) {
        System.out.format("[%s]%n",
            test.replaceAll("^ +| +$|( )+", "$1")
        );
    }

Es gibt 3 Alternativen:

• ^_+: eine beliebige Folge von Leerzeichen am Anfang der Zeichenfolge
  • Stimmen Sie ab und ersetzen Sie es mit $1, wodurch die leere Zeichenfolge erfasst wird
• _+$: eine beliebige Folge von Leerzeichen am Ende der Zeichenfolge
  • Stimmen Sie ab und ersetzen Sie es mit $1, wodurch die leere Zeichenfolge erfasst wird
• (_)+: eine beliebige Folge von Leerzeichen, die mit keiner der obigen Angaben übereinstimmt, dh sie befindet sich in der Mitte.
  • Gleiche Übereinstimmung mit $1, die ein einzelnes Leerzeichen erfasst

Siehe auch

• regular-expressions.info/Anchors

Sie brauchen nur ein:

replaceAll("\\s{2,}", " ").trim();

hier passen Sie ein oder mehrere Leerzeichen an, und ersetzen Sie sie durch ein einzelnes Leerzeichen. Anschließend werden die Leerzeichen am Anfang und am Ende abgeschnitten.

Um dies schnell zu testen, versuchen Sie Folgendes:

System.out.println(new String(" hello     there   ").trim().replaceAll("\\s{2,}", " "));

und es wird zurückkehren: 

"hello there"

Verwenden Sie die Apache Commons StringUtils.normalizeSpace(String str)-Methode. docs hier

Das funktionierte perfekt für mich: sValue = sValue.trim().replaceAll("\\s+", " ");

Verwenden Sie die String#trim()-Methode, um Leerzeichen am Anfang und am Ende der Zeichenfolge zu entfernen. Und dann benutzen Sie Ihre mytext.replaceAll("( )+", " ").

Sie können zuerst String.trim() verwenden und dann den Befehl zum Ersetzen des regulären Ausdrucks auf das Ergebnis anwenden.

Probier diese.

Beispielcode

String str = " hello     there   ";
System.out.println(str.replaceAll("( +)"," ").trim());

AUSGABE

hello there

Zuerst werden alle Leerzeichen durch ein Leerzeichen ersetzt. Dann müssen wir String trimmen, da das Starten von String und End von String das gesamte Leerzeichen durch ein Leerzeichen ersetzt, wenn String Leerzeichen am Anfang von String und Ende von String hat. Dann erhalten Sie Ihre gewünschte String.

"[ ]{2,}"

Dies entspricht mehr als einem Leerzeichen.

String mytext = " hello     there   ";
//without trim -> " hello there"
//with trim -> "hello there"
mytext = mytext.trim().replaceAll("[ ]{2,}", " ");
System.out.println(mytext);

AUSGABE:

hello there

Sie könnten auch Lookarounds verwenden.

test.replaceAll("^ +| +$|(?<= ) ", "");

ODER

test.replaceAll("^ +| +$| (?= )", "")

<space>(?= ) stimmt mit einem Leerzeichen überein, dem ein anderes Leerzeichen folgt. In aufeinanderfolgenden Leerzeichen würde es mit allen Leerzeichen außer dem letzten übereinstimmen, da kein Leerzeichen folgt. Dadurch bleibt nach dem Entfernungsvorgang nur noch ein Platz für aufeinander folgende Leerzeichen. 

Beispiel:

    String[] tests = {
            "  x  ",          // [x]
            "  1   2   3  ",  // [1 2 3]
            "",               // []
            "   ",            // []
        };
        for (String test : tests) {
            System.out.format("[%s]%n",
                test.replaceAll("^ +| +$| (?= )", "")
            );
        }

trimmen()

Entfernt nur die führenden und nachgestellten Leerzeichen.

Von Java Doc. "Gibt eine Zeichenfolge zurück, deren Wert diese Zeichenfolge ist, wobei führende und nachgestellte Leerzeichen entfernt werden."

System.out.println(" D ev  Dum my ".trim());

"D ev Dum my"

replace (), replaceAll ()

Ersetzt alle leeren Zeichenfolgen im Wort.

System.out.println(" D ev  Dum my ".replace(" ",""));

System.out.println(" D ev  Dum my ".replaceAll(" ",""));

System.out.println(" D ev  Dum my ".replaceAll("\\s+",""));

Ausgabe:

"DevDummy"

"DevDummy"

"DevDummy"

Hinweis: "\ s +" ist der reguläre Ausdruck, der dem Leerzeichen ähnelt.

Referenz: https://www.codedjava.com/2018/06/replace-all-spaces-in-string-trim.html

Hallo Entschuldigung für die Verzögerung! Hier ist die beste und effizienteste Antwort, die Sie suchen:

import Java.util.regex.Matcher;
import Java.util.regex.Pattern;

public class MyPatternReplace {

public String replaceWithPattern(String str,String replace){

    Pattern ptn = Pattern.compile("\\s+");
    Matcher mtch = ptn.matcher(str);
    return mtch.replaceAll(replace);
}

public static void main(String a[]){
    String str = "My    name    is  kingkon.  ";
    MyPatternReplace mpr = new MyPatternReplace();
    System.out.println(mpr.replaceWithPattern(str, " "));
}

Ihre Ausgabe dieses Beispiels lautet also: Mein Name ist kingkon.  

Diese Methode entfernt jedoch auch das "\ n", das Ihre Zeichenfolge enthalten kann. Wenn Sie das nicht möchten, verwenden Sie einfach diese einfache Methode:

while (str.contains("  ")){  //2 spaces
str = str.replace("  ", " "); //(2 spaces, 1 space) 
}

Und wenn Sie auch die führenden und nachfolgenden Leerzeichen entfernen möchten, fügen Sie einfach Folgendes hinzu:

str = str.trim();

Das hat bei mir funktioniert

scan= filter(scan, " [\\s]+", " ");
scan= sac.trim();

wobei filter folgende Funktion ist und scan der Eingabestring ist:

public String filter(String scan, String regex, String replace) {
    StringBuffer sb = new StringBuffer();

    Pattern pt = Pattern.compile(regex);
    Matcher m = pt.matcher(scan);

    while (m.find()) {
        m.appendReplacement(sb, replace);
    }

    m.appendTail(sb);

    return sb.toString();
}

du solltest es so machen

String mytext = " hello     there   ";
mytext = mytext.replaceAll("( +)", " ");

+ in runde Klammern setzen.

String str = " hello world"

leerzeichen zuerst reduzieren 

str = str.trim().replaceAll(" +", " ");

den ersten Buchstaben groß und alles andere in Kleinschreibung

str = str.substring(0,1).toUpperCase() +str.substring(1,str.length()).toLowerCase();

Meine Methode vor der zweiten Antwort fand ich mit Regex als bessere Lösung. Vielleicht braucht jemand diesen Code.

private String replaceMultipleSpacesFromString(String s){
    if(s.length() == 0 ) return "";

    int timesSpace = 0;
    String res = "";

    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);

        if(c == ' '){
            timesSpace++;
            if(timesSpace < 2)
                res += c;
        }else{
            res += c;
            timesSpace = 0;
        }
    }

    return res.trim();
}

Stream-Version, filtert Leerzeichen und Registerkarten.

Stream.of(str.split("[ \\t]")).filter(s -> s.length() > 0).collect(Collectors.joining(" "))

Mit dem folgenden Code werden Leerzeichen zwischen Wörtern komprimiert und am Anfang und Ende der Zeichenfolge entfernt

String input = "\n\n\n  a     string with     many    spaces,    \n"+
               " a \t tab and a newline\n\n";
String output = input.trim().replaceAll("(\\s)+", " ");
System.out.println(output);

Dies wird a string with many spaces, a tab and a newline ausgeben

Beachten Sie, dass nicht druckbare Zeichen, einschließlich Leerzeichen, Tabulatoren und Zeilenumbrüchen, komprimiert oder entfernt werden

Weitere Informationen finden Sie in der jeweiligen Dokumentation:

• String # trim () method
• String # replaceAll (String-Regex, String-Ersetzung) Methode
• Informationen zur Implementierung von regulären Ausdrücken in Java finden Sie in der Dokumentation des Pattern class

Überprüfen Sie dies...

public static void main(String[] args) {
    String s = "A B  C   D    E F      G\tH I\rJ\nK\tL";
    System.out.println("Current      : "+s);
    System.out.println("Single Space : "+singleSpace(s));
    System.out.println("Space  count : "+spaceCount(s));
    System.out.format("Replace  all = %s", s.replaceAll("\\s+", ""));

    // Example where it uses the most.
    String s = "My name is yashwanth . M";
    String s2 = "My nameis yashwanth.M";

    System.out.println("Normal  : "+s.equals(s2));
    System.out.println("Replace : "+s.replaceAll("\\s+", "").equals(s2.replaceAll("\\s+", "")));

} 

Wenn String nur ein Leerzeichen enthält, wird replace () nicht ersetzt. 

Wenn Leerzeichen mehr als eins sind, wird die Dann-Aktion ausgeführt und entfernt den Abstand.

public static String singleSpace(String str){
    return str.replaceAll("  +|   +|\t|\r|\n","");
}

So zählen Sie die Anzahl der Leerzeichen in einem String.

public static String spaceCount(String str){
    int i = 0;
    while(str.indexOf(" ") > -1){
      //str = str.replaceFirst(" ", ""+(i++));
        str = str.replaceFirst(Pattern.quote(" "), ""+(i++)); 
    }
    return str;
}

Pattern . Quote ("?") Gibt den Literalmuster-String zurück.

Siehe String.replaceAll.

Verwenden Sie den Regex "\s" und ersetzen Sie ihn durch " ".

Dann benutze String.trim.

Ich weiß, dass die Methode replaceAll viel einfacher ist, aber ich wollte dies auch posten.

public static String removeExtraSpace(String input) {
    input= input.trim();
    ArrayList <String> x= new ArrayList<>(Arrays.asList(input.split("")));
    for(int i=0; i<x.size()-1;i++) {
        if(x.get(i).equals(" ") && x.get(i+1).equals(" ")) { 
            x.remove(i); 
            i--; 
        }
    }
    String Word="";
    for(String each: x) 
        Word+=each;
    return Word;
}