Java cómo reemplazar 2 o más espacios con un solo espacio en cadena y eliminar espacios iniciales y finales

271

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.

Nessa
fuente
55
Debería considerar aceptar una respuesta. Hace que sea mucho más fácil para las personas que llegan a la página más tarde elegir una solución definitiva.
Paul Rooney
1
Esta es una de las formas más recomendadas. =>. String nameWithProperSpacing = StringUtils.normalizeSpace (stringWithLotOfSpaces);
Kunal Vohra
s = s.replaceAll ("\\ s +", "");
Saroj Kumar Sahoo

Respuestas:

462

Prueba esto:

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

Ver también


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

poligenelubricantes
fuente
11
+1, especialmente porque vale la pena señalar eso trim()y luego replaceAll()usa menos memoria que hacerlo al revés. No por mucho, pero si esto se llama muchas veces, podría sumar, especialmente si hay mucho "espacio en blanco recortable". ( Trim()En realidad no deshacerse del espacio extra - sólo lo oculta moviendo los valores inicial y final del Subyacente. char[]Se mantiene sin cambios.)
corsiKa
2
Es solo un detalle, pero creo que ( ) +o ( ){2,}debería ser un (muy) poco más eficiente;)
sp00m
66
Buena expresión regular. Nota: reemplazar el espacio `` con \\sreemplazará cualquier grupo de espacios en blanco con el carácter deseado.
djmj
1
Tenga en cuenta que la parte () + coincidirá con un solo espacio y lo reemplazará con un solo espacio. Tal vez (<space> <space> +) sería mejor, por lo que solo coincide si hay varios espacios y el reemplazo hará un cambio neto en la cadena.
Lee Meador
2
Como mencionó Lee Meador, .trim().replaceAll(" +", " ")(con dos espacios) es más rápido que .trim().replaceAll(" +", " ")(con un espacio). Realicé pruebas de temporización en cadenas que solo tenían espacios individuales y todos los espacios dobles, y fue mucho más rápido para ambos cuando hacía muchas operaciones (millones o más, dependiendo del entorno).
Gary S. Weaver el
154

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"
sarah.ferguson
fuente
3
Probablemente recortaría primero porque luego estás ahorrando un poco de trabajo a la expresión regular.
Michael
3
@ sarah.ferguson Elimine el soporte final ")" que no debería estar allí en el primer reemplazo. Gracias. - ¡El sistema no me dejaba hacerlo! (Nada menos que 6 caracteres es elegible para una edición ..)
mwarren
2
Tenga en cuenta que esto reemplaza un espacio con otro espacio en el caso de que no haya múltiples espacios juntos. No es necesario hacer el reemplazo en ese caso, aunque es posible que lo desee ya que también está reemplazando una pestaña con un solo espacio. Sería bueno reconocer solo espacios múltiples.
Lee Meador
2
@geowar, ¿dónde pidió la pregunta pestañas lo siento? Estoy seguro de que lo anterior no reemplaza los símbolos ☮ también para el caso ... y tampoco ✌ ...
sarah.ferguson
2
espere un segundo @geowar Esto reemplaza una sola tabla con un espacio. Lo acabo de probar
user1870400
42

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

Monica Granbois
fuente
Buena idea, pero esto elimina las nuevas líneas entre otras cosas
Somaiah Kumbera
20

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

Médico
fuente
1
La gente editó mi respuesta. El original era: sValue = sValue.replaceAll ("\ s +", "") .trim ();
Doctor
2
Fue editado porque su respuesta original elimina todos los espacios y eso no es lo que el OP preguntó
Jose Rui Santos
17
"[ ]{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
Gitesh Dalal
fuente
13

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

folone
fuente
12

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

Eyal Schneider
fuente
10
trim () eliminará todo el espacio al comienzo y al final de la cadena, no se aplica para el espacio entre palabras
vuhung3990
10

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:

xcuipir
fuente
9

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.

Raj S. Rusia
fuente
4

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("^ +| +$| (?= )", "")
            );
        }
Avinash Raj
fuente
De la forma en que lo tenga, coincidirá con cualquier espacio en el frente o el final o cualquier espacio con otro espacio después. Eso significa que "a .... b" coincidirá 3 veces y reemplazará tres veces. Se itera sobre todos los espacios internos dentro del método replaceAll (). Quizás podría cambiarlo para que coincida con cualquier secuencia de 2 o más espacios a la vez y reducir la iteración interna.
Lee Meador
Quizás <space> + (? = <space>) lo haría.
Lee Meador
4

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

Sameera
fuente
4

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.

Kunal Vohra
fuente
3

En Kotlin se vería así

val input = "\n\n\n  a     string with     many    spaces,    \n"
val cleanedInput = input.trim().replace(Regex("(\\s)+"), " ")
Rafael
fuente
2
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();
KhaledMohamedP
fuente
2
mytext = mytext.replaceAll("\\s+"," ");
k sarath
fuente
Se desaconsejan las respuestas de solo código. Haga clic en editar y agregue algunas palabras que resuman cómo su código aborda la pregunta, o tal vez explique cómo su respuesta difiere de las respuestas anteriores. Gracias
Nick
1

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();
}
Mr_Hmp
fuente
1
Esto reemplazaría <space> <tab> con un espacio pero no <tab> <tab>. Ese es un problema menor, parece.
Lee Meador
1

deberías hacerlo así

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

poner + dentro de corchetes redondos.

kiro malak
fuente
1
String str = "  this is string   ";
str = str.replaceAll("\\s+", " ").trim();
Ajinkya_M
fuente
0

Ver String.replaceAll.

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

Entonces usar String.trim.

Zak
fuente
1
new String ("hello there") .replaceAll ("\\ s", "+") devuelve a + hello +++++++ there +++, así que definitivamente no funciona ..
sarah.ferguson
1
Probarnew String(" hello there ").trim().replaceAll("\\s+", " ")
manish_s
0

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.

Yash
fuente
0

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();
}
trinity420
fuente
Interesante, pero el espacio en blanco significa más que solo espacios en blanco.
Laur Ivan
@LaurIvan, ¿qué quieres decir?
trinity420
Esta entrada tiene una buena explicación de lo que \ssignifica en expresiones regulares (espacio, tabulación, nueva línea, avance de formulario).
Laur Ivan
@LaurIvan Tu enlace está roto pero tienes razón. Este problema podría resolverse iterando a través de la cadena de entrada, eliminando todos los caracteres no alfabéticos, no numéricos y sin espacio, creo.
trinity420
0

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

Stream.of(str.split("[ \\t]")).filter(s -> s.length() > 0).collect(Collectors.joining(" "))
Aris2World
fuente
0
String myText = "   Hello     World   ";
myText = myText.trim().replace(/ +(?= )/g,'');


// Output: "Hello World"
Alaska
fuente
0

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;
}
Sandun Susantha
fuente
-1
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.

devmohd
fuente
-1

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

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();
kostas poimenidhs
fuente
-1

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;
}
esranur
fuente
1
Aunque esto funciona, está lejos de ser la solución más fácil.
platzhersh
-1

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