Recherche d'un moyen rapide et simple en Java pour changer cette chaîne

" hello     there   "

à quelque chose qui ressemble à ceci

"hello there"

où je remplace tous ces espaces multiples par un seul espace, sauf que je veux aussi que le ou les espaces au début de la chaîne disparaissent.

Quelque chose comme ça me fait en partie là

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

mais pas tout à fait.

Essaye ça:

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

Voir également

• String.trim()
  • Renvoie une copie de la chaîne, les espaces de début et de fin étant omis.
• regular-expressions.info/Repetition

Aucun trim()regex

Il est également possible de le faire avec un seul replaceAll, mais cela est beaucoup moins lisible que la trim()solution. Néanmoins, il est fourni ici juste pour montrer ce que regex peut faire:

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

Il y a 3 suppléants:

• ^_+ : toute séquence d'espaces au début de la chaîne
  • Correspondance et remplacement par $1, qui capture la chaîne vide
• _+$ : toute séquence d'espaces à la fin de la chaîne
  • Correspondance et remplacement par $1, qui capture la chaîne vide
• (_)+ : toute séquence d'espaces qui ne correspond à rien de ce qui précède, ce qui signifie qu'elle est au milieu
  • Match and replace with $1, qui capture un seul espace

Voir également

• regular-expressions.info/Anchors

Vous avez juste besoin d'un:

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

où vous faites correspondre un ou plusieurs espaces et les remplacez par un seul espace, puis coupez les espaces blancs au début et à la fin (vous pouvez en fait inverser en coupant d'abord puis en faisant correspondre pour rendre l'expression régulière plus rapide comme quelqu'un l'a souligné).

Pour tester cela rapidement, essayez:

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

et il renverra:

"hello there"

Utilisez la StringUtils.normalizeSpace(String str)méthode Apache commons . Voir les documents ici

Cela a parfaitement fonctionné pour moi: sValue = sValue.trim().replaceAll("\\s+", " ");

"[ ]{2,}"

Cela correspondra à plus d'un espace.

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

PRODUCTION:

hello there

Pour éliminer les espaces au début et à la fin de la chaîne, utilisez la String#trim()méthode. Et puis utilisez votre mytext.replaceAll("( )+", " ").

Vous pouvez d'abord utiliser String.trim(), puis appliquer la commande regex replace sur le résultat.

Le code suivant compacte tout espace entre les mots et en supprime tout au début et à la fin de la chaîne

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

Cela produira a string with many spaces, a tab and a newline

Notez que tous les caractères non imprimables, y compris les espaces, les tabulations et les nouvelles lignes seront compactés ou supprimés

Pour plus d'informations, consultez la documentation correspondante:

• String # trim (), méthode
• Méthode String # replaceAll (String regex, String replacement)
• Pour plus d'informations sur l'implémentation des expressions régulières de Java, consultez la documentation de la classe Pattern

Essaye celui-là.

Exemple de code

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

PRODUCTION

hello there

Tout d'abord, il remplacera tous les espaces par un seul espace. Que nous devons supposer faire le découpage, Stringcar le début du Stringet la fin du Stringremplacera tout l'espace par un seul espace s'il y Stringa des espaces au début du Stringet à la fin du Stringdonc nous devons les découper. Que vous obtenez votre désir String.

Vous pouvez également utiliser des contournements.

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

OU

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

<space>(?= )correspond à un caractère espace qui est suivi d'un autre caractère espace. Donc, dans des espaces consécutifs, il correspondrait à tous les espaces sauf le dernier car il n'est pas suivi d'un caractère d'espace. Cela vous laisse un seul espace pour les espaces consécutifs après l'opération de suppression.

Exemple:

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

réduire()

Supprime uniquement les espaces de début et de fin.

À partir de Java Doc, "Renvoie une chaîne dont la valeur est cette chaîne, sans les espaces de début et de fin supprimés."

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

"D ev Dum my"

replace (), replaceAll ()

Remplace toutes les chaînes vides du mot,

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

Production:

"DevDummy"

"DevDummy"

"DevDummy"

Remarque: "\ s +" est l'expression régulière similaire au caractère d'espace vide.

Référence: https://www.codedjava.com/2018/06/replace-all-spaces-in-string-trim.html

Beaucoup de réponses correctes ont été fournies jusqu'à présent et je vois beaucoup de votes positifs. Cependant, les manières mentionnées fonctionneront mais pas vraiment optimisées ou pas vraiment lisibles. J'ai récemment découvert la solution qui plaira à tous les développeurs.

String nameWithProperSpacing = StringUtils.normalizeSpace( stringWithLotOfSpaces );

Vous avez terminé. C'est une solution lisible.

À Kotlin, cela ressemblerait à ceci

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

String str = " hello world"

réduire d'abord les espaces

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

mettre en majuscule la première lettre et tout le reste en minuscules

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

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

Cela a fonctionné pour moi

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

où le filtre est la fonction suivante et scan est la chaîne d'entrée:

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

tu devrais le faire comme ça

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

mettre + entre parenthèses rondes.

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

Tu vois String.replaceAll.

Utilisez l'expression régulière "\s"et remplacez-la par " ".

Ensuite, utilisez String.trim.

vérifie ça...

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

} 

Si String ne contient qu'un seul espace, replace () ne remplacera pas,

Si les espaces sont plus d'un, l'action Replace replace () effectue et supprime les espaces.

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

Pour compter le nombre d'espaces dans une chaîne.

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

Le motif .quote ("?") Renvoie le motif littéral String.

Ma méthode avant de trouver la deuxième réponse en utilisant l'expression régulière comme meilleure solution. Peut-être que quelqu'un a besoin de ce 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();
}

Version Stream, filtre les espaces et les tabulations.

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"

La méthode la plus simple pour supprimer les espaces blancs n'importe où dans la chaîne.

 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 solution ci-dessus est l'algorithme avec la complexité de O (n) sans utiliser de fonction java.

Veuillez utiliser le code ci-dessous

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

Bonjour désolé pour le retard! Voici la réponse la meilleure et la plus efficace que vous recherchez:

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

Donc, votre sortie de cet exemple sera: Mon nom est kingkon.

Cependant, cette méthode supprimera également le "\ n" que peut contenir votre chaîne. Donc, si vous ne le souhaitez pas, utilisez simplement cette méthode simple:

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

Et si vous souhaitez également supprimer les espaces de début et de fin, ajoutez simplement:

str = str.trim();

Je sais que la méthode replaceAll est beaucoup plus facile, mais je voulais également la publier.

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

Le Tokenizer de chaîne peut être utilisé

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