Procurando uma maneira rápida e simples em Java para alterar essa sequência

" hello     there   "

para algo que se parece com isso

"hello there"

onde eu substituo todos esses espaços múltiplos por um único espaço, exceto que também quero que um ou mais espaços no início da string sejam removidos.

Algo assim me deixa parcialmente lá

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

mas não exatamente.

Tente o seguinte:

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

Veja também

• String.trim()
  • Retorna uma cópia da string, com espaços em branco à esquerda e à direita omitidos.
• regular-expressions.info/Repetition

Sem trim()regex

Também é possível fazer isso com apenas um replaceAll, mas isso é muito menos legível que a trim()solução. No entanto, é fornecido aqui apenas para mostrar o que a regex pode fazer:

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

Existem 3 alternativas:

• ^_+ : qualquer sequência de espaços no início da sequência
  • Combine e substitua por $1, que captura a sequência vazia
• _+$ : qualquer sequência de espaços no final da sequência
  • Combine e substitua por $1, que captura a sequência vazia
• (_)+ : qualquer sequência de espaços que não corresponda a nenhuma das opções acima, o que significa que está no meio
  • Combine e substitua por $1, que captura um único espaço

Veja também

• regular-expressions.info/Anchors

Você só precisa de:

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

onde você corresponde a um ou mais espaços, substitui-os por um único espaço e, em seguida, apara os espaços em branco no início e no final (você pode inverter primeiro aparando e depois combinando para tornar a regex mais rápida, como alguém apontou).

Para testar isso, tente rapidamente:

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

e retornará:

"hello there"

Use o StringUtils.normalizeSpace(String str)método Apache commons . Veja os documentos aqui

Isso funcionou perfeitamente para mim: sValue = sValue.trim().replaceAll("\\s+", " ");

"[ ]{2,}"

Isso corresponderá a mais de um espaço.

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

RESULTADO:

hello there

Para eliminar espaços no início e no final da String, use o String#trim()método E então use o seu mytext.replaceAll("( )+", " ").

Você pode primeiro usar String.trim()e, em seguida, aplicar o comando regex replace no resultado.

O código a seguir compactará qualquer espaço em branco entre as palavras e removerá qualquer no início e no final da string

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

Isso produzirá a string with many spaces, a tab and a newline

Observe que quaisquer caracteres não imprimíveis, incluindo espaços, guias e novas linhas, serão compactados ou removidos

Para mais informações, consulte a respectiva documentação:

• Método string # trim ()
• String # replaceAll (String regex, substituição String) método
• Para obter informações sobre a implementação da expressão regular do Java, consulte a documentação da classe Pattern.

Tente este.

Código de amostra

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

RESULTADO

hello there

Primeiro, ele substituirá todos os espaços por espaço único. Do que devemos fazer o corte, Stringporque o Início do Stringe o Fim do Stringmesmo substituirão todo o espaço por um espaço único, se Stringhouver espaços no Início do Stringe Fim do StringEntão, precisamos apará-los. Do que você deseja String.

Você também pode usar lookarounds.

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

OU

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

<space>(?= )corresponde a um caractere de espaço que é seguido por outro caractere de espaço. Portanto, em espaços consecutivos, ele corresponderia a todos os espaços, exceto o último, porque não é seguido por um caractere de espaço. Isso deixa um espaço único para espaços consecutivos após a operação de remoção.

Exemplo:

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

aparar()

Remove apenas os espaços iniciais e finais.

No Java Doc, "Retorna uma string cujo valor é essa string, com qualquer espaço em branco à esquerda e à direita removido".

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

"D ev Dum my"

replace (), replaceAll ()

Substitui todas as cadeias vazias na palavra,

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

Resultado:

"DevDummy"

"DevDummy"

"DevDummy"

Nota: "\ s +" é a expressão regular semelhante ao caractere de espaço vazio.

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

Muitas respostas corretas foram fornecidas até agora e vejo muitas votações. No entanto, as formas mencionadas funcionarão, mas não serão realmente otimizadas ou não serão legíveis. Recentemente, deparei com a solução que todos os desenvolvedores vão gostar.

String nameWithProperSpacing = StringUtils.normalizeSpace( stringWithLotOfSpaces );

Você terminou. Esta é uma solução legível.

Em Kotlin, ficaria assim

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

String str = " hello world"

reduza os espaços primeiro

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

colocar em maiúscula a primeira letra e minúsculas em todo o resto

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

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

Isso funcionou para mim

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

onde filtro está seguindo a função e varredura é a sequência 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();
}

você deveria fazer assim

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

coloque + dentro de colchetes.

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

Veja String.replaceAll.

Use o regex "\s"e substitua por " ".

Então use String.trim.

verifique isso ...

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 contiver apenas espaço único, replace () não substituirá,

Se os espaços forem mais de um, a ação Substituir () executa e remove o espaço.

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

Contar o número de espaços em uma String.

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 ("?") Retorna o padrão literal String.

Meu método antes de encontrar a segunda resposta usando o regex como uma solução melhor. Talvez alguém precise desse 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();
}

Versão de fluxo, filtra espaços e tabulações.

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"

O método mais simples para remover espaços em branco em qualquer lugar da string.

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

A solução acima é o algoritmo com a complexidade de O (n) sem usar nenhuma função java.

Por favor, use o código abaixo

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

Olá desculpe pelo atraso! Aqui está a melhor e mais eficiente resposta que você está procurando:

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

Portanto, sua saída deste exemplo será: Meu nome é kingkon.

No entanto, este método removerá também o "\ n" que sua string pode ter. Portanto, se você não quiser, basta usar este método simples:

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

E se você quiser remover também os espaços à esquerda e à direita, adicione:

str = str.trim();

Eu sei que o método replaceAll é muito mais fácil, mas eu queria postar isso também.

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

O Tokenizer de String pode ser usado

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