Buscando una forma rápida y sencilla en Java para cambiar esta cadena

" hello     there   "

a algo que se parece a esto

"hello there"

donde reemplazo todos esos espacios múltiples con un solo espacio, excepto que también quiero que uno o más espacios al comienzo de la cadena desaparezcan.

Algo como esto me lleva en parte

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

pero no del todo.

Prueba esto:

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

Ver también

• String.trim()
  • Devuelve una copia de la cadena, con espacios en blanco iniciales y finales omitidos.
• regular-expressions.info/Repetition

Sin trim()expresiones regulares

También es posible hacer esto con solo uno replaceAll, pero esto es mucho menos legible que la trim()solución. No obstante, se proporciona aquí solo para mostrar lo que puede hacer la expresión regular:

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

Hay 3 alternativas:

• ^_+ : cualquier secuencia de espacios al comienzo de la cadena
  • Empareja y reemplaza con $1, que captura la cadena vacía
• _+$ : cualquier secuencia de espacios al final de la cadena
  • Empareja y reemplaza con $1, que captura la cadena vacía
• (_)+ : cualquier secuencia de espacios que no coincida con ninguno de los anteriores, lo que significa que está en el medio
  • Combina y reemplaza con $1, que captura un solo espacio

Ver también

• regular-expressions.info/Anchors

Solo necesitas un:

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

donde empareja uno o más espacios y los reemplaza con un solo espacio y luego recorta los espacios en blanco al principio y al final (en realidad, podría invertir primero recortando y luego haciendo coincidir para que la expresión regular sea más rápida como alguien señaló).

Para probar esto rápidamente, intente:

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

y volverá:

"hello there"

Use el StringUtils.normalizeSpace(String str)método de Apache commons . Ver documentos aquí

Esto funcionó perfectamente para mí : sValue = sValue.trim().replaceAll("\\s+", " ");

"[ ]{2,}"

Esto coincidirá con más de un espacio.

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

SALIDA:

hello there

Para eliminar espacios al principio y al final de la cadena, utilice el String#trim()método. Y luego usa tu mytext.replaceAll("( )+", " ").

Primero puede usar String.trim(), y luego aplicar el comando regex replace en el resultado.

El siguiente código compactará cualquier espacio en blanco entre las palabras y eliminará cualquiera al principio y al final de la cadena

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

Esto dará salida a string with many spaces, a tab and a newline

Tenga en cuenta que los caracteres no imprimibles, incluidos espacios, pestañas y líneas nuevas, se compactarán o eliminarán

Para obtener más información, consulte la documentación respectiva:

• Método de cadena # trim ()
• Cadena # replaceAll (cadena de expresiones regulares, la sustitución de cadena) método
• Para obtener información sobre la implementación de expresiones regulares de Java, consulte la documentación de la clase Pattern

Prueba este.

Código de muestra

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

SALIDA

hello there

Primero reemplazará todos los espacios con un solo espacio. De lo que tenemos que hacer para recortar Stringporque el inicio de Stringy el final de la Stringmisma reemplazará todo el espacio con un solo espacio si Stringtiene espacios en el inicio Stringy el final de la, por Stringlo que debemos recortarlos. De lo que obtienes tu deseado String.

También puedes usar lookarounds.

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

O

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

<space>(?= )coincide con un carácter de espacio seguido de otro carácter de espacio. Por lo tanto, en espacios consecutivos, coincidiría con todos los espacios excepto el último porque no está seguido por un carácter de espacio. Esto le deja un espacio único para espacios consecutivos después de la operación de eliminación.

Ejemplo:

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

podar()

Elimina solo los espacios iniciales y finales.

De Java Doc, "Devuelve una cadena cuyo valor es esta cadena, con cualquier espacio en blanco inicial y final eliminado".

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

"D ev Dum my"

replace (), replaceAll ()

Reemplaza todas las cadenas vacías en la palabra,

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

Salida:

"DevDummy"

"DevDummy"

"DevDummy"

Nota: "\ s +" es la expresión regular similar al carácter de espacio vacío.

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

Se han proporcionado muchas respuestas correctas hasta ahora y veo muchas votaciones positivas. Sin embargo, las formas mencionadas funcionarán pero no están realmente optimizadas o no son realmente legibles. Recientemente encontré la solución que le gustará a cada desarrollador.

String nameWithProperSpacing = StringUtils.normalizeSpace( stringWithLotOfSpaces );

Estás listo. Esta es una solución legible.

En Kotlin se vería así

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

String str = " hello world"

reducir espacios primero

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

escribe en mayúscula la primera letra y en minúscula todo lo demás

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

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

Esto funciono para mi

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

donde filter sigue la función y scan es la cadena de entrada:

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

deberías hacerlo así

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

poner + dentro de corchetes redondos.

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

Ver String.replaceAll.

Use la expresión regular "\s"y reemplace con " ".

Entonces usar String.trim.

Mira esto...

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 contiene solo un espacio, entonces replace () no reemplazará,

Si los espacios son más de uno, la acción Reemplazar () realiza y elimina el espacio.

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

Para contar el número de espacios en una cadena.

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 ("?") Devuelve la cadena de patrón literal.

Mi método antes de encontrar la segunda respuesta usando regex como una mejor solución. Quizás alguien necesita este código.

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

Versión Stream, filtra espacios y pestañas.

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"

El método más simple para eliminar espacios en blanco en cualquier parte de la cadena.

 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 solución anterior es el algoritmo con la complejidad de O (n) sin usar ninguna función de Java.

Por favor use el siguiente código

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

Hola perdón por la demora! Aquí está la mejor y más eficiente respuesta que está buscando:

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

Entonces, la salida de este ejemplo será: Mi nombre es kingkon.

Sin embargo, este método eliminará también el "\ n" que puede tener su cadena. Entonces, si no quieres eso, solo usa este método simple:

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

Y si también desea eliminar los espacios iniciales y finales, simplemente agregue:

str = str.trim();

Sé que el método replaceAll es mucho más fácil, pero también quería publicar esto.

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

Tokenizer de cadena se puede utilizar

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