Alla ricerca di un modo rapido e semplice per modificare questa stringa in Java

" hello     there   "

a qualcosa che assomiglia a questo

"hello there"

dove sostituisco tutti quegli spazi multipli con un unico spazio, tranne che voglio anche che uno o più spazi all'inizio della stringa scompaiano.

Qualcosa del genere mi porta in parte lì

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

ma non del tutto.

Prova questo:

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

Guarda anche

• String.trim()
  • Restituisce una copia della stringa, con spazi bianchi iniziali e finali omessi.
• regular-expressions.info/Repetition

Nessuna trim()regex

È anche possibile farlo con uno solo replaceAll, ma questo è molto meno leggibile della trim()soluzione. Tuttavia, viene fornito qui solo per mostrare cosa può fare regex:

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

Ci sono 3 supplenti:

• ^_+ : qualsiasi sequenza di spazi all'inizio della stringa
  • Abbina e sostituisci con $1, che acquisisce la stringa vuota
• _+$ : qualsiasi sequenza di spazi alla fine della stringa
  • Abbina e sostituisci con $1, che acquisisce la stringa vuota
• (_)+ : qualsiasi sequenza di spazi che non corrisponde a nessuno dei precedenti, nel senso che è nel mezzo
  • Abbina e sostituisci con $1, che acquisisce un singolo spazio

Guarda anche

• regular-expressions.info/Anchors

Hai solo bisogno di un:

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

dove abbini uno o più spazi e li sostituisci con un singolo spazio e poi ritaglia gli spazi bianchi all'inizio e alla fine (potresti effettivamente invertire prima tagliando e poi abbinando per rendere il regex più veloce come qualcuno ha sottolineato).

Per provarlo rapidamente prova:

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

e restituirà:

"hello there"

Usa il StringUtils.normalizeSpace(String str)metodo commons di Apache . Vedi i documenti qui

Ha funzionato perfettamente per me : sValue = sValue.trim().replaceAll("\\s+", " ");

"[ ]{2,}"

Questo corrisponderà a più di uno spazio.

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

PRODUZIONE:

hello there

Per eliminare gli spazi all'inizio e alla fine della stringa, utilizzare il String#trim()metodo E poi usa il tuo mytext.replaceAll("( )+", " ").

È possibile innanzitutto utilizzare String.trim()e quindi applicare il comando regex replace sul risultato.

Il codice seguente compatta qualsiasi spazio bianco tra le parole e rimuove qualsiasi all'inizio e alla fine della stringa

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

Questo produrrà a string with many spaces, a tab and a newline

Si noti che tutti i caratteri non stampabili inclusi spazi, tabulazioni e nuove righe verranno compattati o rimossi

Per ulteriori informazioni consultare la relativa documentazione:

• Metodo String # trim ()
• String # replaceAll (String regex, la sostituzione String) Metodo
• Per informazioni sull'implementazione delle espressioni regolari di Java, consultare la documentazione della classe Pattern

Prova questo.

Codice di esempio

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

PRODUZIONE

hello there

Innanzitutto sostituirà tutti gli spazi con spazio singolo. Di quello che dovremmo fare per tagliare Stringperché Inizio di Stringe Fine di Stringesso sostituirà tutto lo spazio con spazio singolo se ci Stringsono spazi in Inizio di Stringe Fine di StringCosì, quindi dobbiamo tagliarli. Di quello che ottieni desiderato String.

Puoi usare anche i lookaround.

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

O

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

<space>(?= )corrisponde a un personaggio spaziale seguito da un altro personaggio spaziale. Quindi, negli spazi consecutivi, corrisponderebbe a tutti gli spazi tranne l'ultimo perché non è seguito da un carattere spazio. Questo ti lascia un singolo spazio per spazi consecutivi dopo l'operazione di rimozione.

Esempio:

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

trim ()

Rimuove solo gli spazi iniziali e finali.

Da Java Doc, "Restituisce una stringa il cui valore è questa stringa, con qualsiasi spazio bianco iniziale e finale rimosso."

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

"D ev Dum my"

replace (), replaceAll ()

Sostituisce tutte le stringhe vuote nella parola,

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+",""));

Produzione:

"DevDummy"

"DevDummy"

"DevDummy"

Nota: "\ s +" è l'espressione regolare simile al carattere di spazio vuoto.

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

Finora sono state fornite molte risposte corrette e vedo molti voti positivi. Tuttavia, i modi citati funzioneranno ma non saranno davvero ottimizzati o non leggibili. Di recente ho trovato la soluzione che piacerà a tutti gli sviluppatori.

String nameWithProperSpacing = StringUtils.normalizeSpace( stringWithLotOfSpaces );

Hai fatto. Questa è una soluzione leggibile.

A Kotlin sembrerebbe così

val input = "\n\n\n  a     string with     many    spaces,    \n"
val cleanedInput = input.trim().replace(Regex("(\\s)+"), " ")

String str = " hello world"

ridurre prima gli spazi

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

scrivere in maiuscolo la prima lettera e minuscole tutto il resto

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

mytext = mytext.replaceAll("\\s+"," ");

Questo ha funzionato per me

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

dove filter sta seguendo la funzione e scan è la stringa di input:

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

dovresti farlo in questo modo

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

mettere + all'interno delle parentesi tonde.

String str = "  this is string   ";
str = str.replaceAll("\\s+", " ").trim();

Vedere String.replaceAll.

Usa regex "\s"e sostituiscilo con " ".

Quindi utilizzare String.trim.

controllare questo...

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+", "")));

} 

Se String contiene solo spazio singolo, allora replace () non sostituirà,

Se gli spazi sono più di uno, quindi l'azione di sostituzione () esegue e rimuove lo spazio.

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

Per contare il numero di spazi in una stringa.

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 ("?") Restituisce il modello letterale String.

Il mio metodo prima ho trovato la seconda risposta usando regex come soluzione migliore. Forse qualcuno ha bisogno di questo codice.

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

Versione streaming, filtri spazi e schede.

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

String myText = "   Hello     World   ";
myText = myText.trim().replace(/ +(?= )/g,'');


// Output: "Hello World"

Il metodo più semplice per rimuovere gli spazi bianchi in qualsiasi punto della stringa.

 public String removeWhiteSpaces(String returnString){
    returnString = returnString.trim().replaceAll("^ +| +$|( )+", " ");
    return returnString;
}

public class RemoveExtraSpacesEfficient {

    public static void main(String[] args) {

        String s = "my    name is    mr    space ";

        char[] charArray = s.toCharArray();

        char prev = s.charAt(0);

        for (int i = 0; i < charArray.length; i++) {
            char cur = charArray[i];
            if (cur == ' ' && prev == ' ') {

            } else {
                System.out.print(cur);
            }
            prev = cur;
        }
    }
}

La soluzione sopra è l'algoritmo con la complessità di O (n) senza usare alcuna funzione java.

Si prega di utilizzare sotto il codice

package com.myjava.string;

import java.util.StringTokenizer;

public class MyStrRemoveMultSpaces {

    public static void main(String a[]){

        String str = "String    With Multiple      Spaces";

        StringTokenizer st = new StringTokenizer(str, " ");

        StringBuffer sb = new StringBuffer();

        while(st.hasMoreElements()){
            sb.append(st.nextElement()).append(" ");
        }

        System.out.println(sb.toString().trim());
    }
}

Ciao scusa per il ritardo! Ecco la risposta migliore e più efficiente che stai cercando:

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

Quindi il tuo risultato di questo esempio sarà: Il mio nome è Kingkon.

Tuttavia, questo metodo rimuoverà anche la "\ n" che potrebbe avere la tua stringa. Quindi, se non lo desideri, usa questo semplice metodo:

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

E se vuoi eliminare anche gli spazi iniziali e finali, aggiungi:

str = str.trim();

So che il metodo di sostituzione Tutto è molto più semplice, ma volevo anche pubblicare questo.

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

È possibile utilizzare Tokenizer per stringhe

 String str = "  hello    there  ";
            StringTokenizer stknzr = new StringTokenizer(str, " ");
            StringBuffer sb = new StringBuffer();
            while(stknzr.hasMoreElements())
            {
                sb.append(stknzr.nextElement()).append(" ");
            }
            System.out.println(sb.toString().trim());