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

Intente esto:

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

Véase también

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

No trim() regex

También es posible hacer esto con un solo replaceAll, pero esto es mucho menos legible que la trim() solución. No obstante, es siempre aquí sólo para mostrar lo que regex puede hacer:

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

Hay 3 suplentes:

• ^_+ : cualquier secuencia de espacios en el principio de la cadena
  • Partido y reemplazar con $1, que captura la cadena vacía
• _+$ : cualquier secuencia de espacios en blanco al final de la cadena
  • Partido y reemplazar con $1, que captura la cadena vacía
• (_)+ : cualquier secuencia de espacios que coincide con ninguno de los de arriba, significa que está en el medio
  • Partido y reemplazar con $1, que captura un solo espacio

Véase también

• regular-expressions.info/Anchors

Sólo se necesita una:

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

donde coincidan uno o más espacios y reemplazarlos con un solo espacio y, a continuación, recorte de espacios en blanco al principio y al final (en realidad se podría invertir por primera recorte y, a continuación, juego de hacer el regex rápido como alguien señaló).

A la prueba tratar rápidamente:

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

y volverá:

"hello there"

Utilizar Apache commons StringUtils.normalizeSpace(String str) método. Ver docs aquí

Este a mi me funciono perfectamente : sValue = sValue.trim().replaceAll("\\s+", " ");

Para eliminar espacios al principio y al final de la Cadena, utilice String#trim() método. Y, a continuación, utilizar su mytext.replaceAll("( )+", " ").

Primero puede utilizar String.trim() y, a continuación, aplicar el regex comando reemplazar en el resultado.

"[ ]{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);

De SALIDA:

hello there

Probar este.

Código De Ejemplo

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

SALIDA

hello there

Primera reemplazará a todos los espacios con un solo espacio. Que tenemos que supone hacer recorte de String porque a Partir de la String y al Final de la String reemplazará el todo el espacio con el único espacio si String tiene espacios en el arranque de la String y al Final de la String Así que tenemos que recortar. De obtener su deseado String.

trim()

Quita sólo el líder & espacios.

De Java Doc,
«Devuelve una cadena cuyo valor es de esta cadena, con cualquier iniciales y finales en los espacios en blanco eliminado.»

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

«D ev Dum mi»

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

De salida:

"DevDummy"

"DevDummy"

"DevDummy"

Nota: «\s+» es la expresión regular similar a la del espacio vacío carácter.

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

Usted podría utilizar lookarounds también.

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

O

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

<space>(?= ) coincide con un carácter de espacio, que es seguido por otro de carácter de espacio. Así, en los espacios consecutivos, coincidiría con todos los espacios, excepto el último, ya que no es seguido por un carácter de espacio. Este dejando 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("^ +| +$| (?= )", "")
            );
        }

String str = " hello world"

reducir los espacios de primera

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

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

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

Esto funcionó para mí

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

donde el filtro es la siguiente función y la exploración 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();
}

usted debe hacer esto de esta

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

poner + dentro de paréntesis.

Versión del flujo, filtros de espacios y tabulaciones.

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

Ver String.replaceAll.

Utilizar el regex "\s" y reemplazar con " ".

A continuación, utilizar String.trim.

comprobar 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 la Cadena contiene solo espacio, a continuación, reemplazar() no reemplazar,

Si los espacios son más de uno, a Continuación, reemplazar() realiza la acción y elimina spacess.

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

Patrón.cita(«?») devuelve literal de Cadena de patrón.

Mi método antes de encontrar la segunda respuesta de usar regex como una solución mejor. Tal vez alguien las necesidades de 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();
}

Hola perdón por la demora!
Aquí es la mejor y la mayoría de la eficiencia de la respuesta que usted 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, " "));
}

Por lo que su salida de este ejemplo será:
Mi nombre es kingkon.

Sin embargo este método eliminará también el «\n» que su cadena de mayo ha. Así que si usted no desea que acaba de utilizar este sencillo método:

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

Y si queremos eliminar los espacios iniciales y finales también acabo de agregar:

str = str.trim();

El siguiente código compacto cualquier espacio en blanco entre las palabras y eliminar cualquier en la cadena comienzo y el final de

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

Esta es la salida a string with many spaces, a tab and a newline

Tenga en cuenta que cualquier caracteres no imprimibles incluidos los espacios, tabulaciones y saltos de línea será compactada o eliminado

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

• Cadena#trim() método
• Cadena#replaceAll(Cadena de regex, Cadena de reemplazo) método
• Para obtener información acerca de Java de expresión regular de la implementación ver el la documentación de la Patrón de la clase

Sé replaceAll método es mucho más fácil, pero yo 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;
}

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 utilizar cualquier función java.

Por favor, utilice a continuación el 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());
    }
}