Bu dizeyi değiştirmek için Java'da hızlı ve basit bir yol mu arıyorsunuz?

" hello     there   "

şuna benzeyen bir şeye

"hello there"

burada dizenin başlangıcındaki bir veya daha fazla boşluğun gitmesini istemiyorum hariç, tüm bu çoklu boşlukları tek bir boşlukla değiştiriyorum.

Böyle bir şey beni kısmen oraya götürüyor

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

ama tam olarak değil.

Bunu dene:

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

Ayrıca bakınız

• String.trim()
  • Dizenin ön ve arka boşlukları atlanmış bir kopyasını döndürür.
• regular-expressions.info/Repetition

trim()Normal ifade yok

Bunu sadece biriyle yapmak da mümkündür replaceAll, ancak bu trim()çözümden daha az okunabilir . Bununla birlikte, burada regex'in neler yapabileceğini göstermek için sağlanmıştır:

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

3 alternatif var:

• ^_+ : dizenin başındaki herhangi bir boşluk dizisi
  • $1Boş dizeyi yakalayan ile eşleştirin ve değiştirin
• _+$ : dizenin sonundaki herhangi bir boşluk dizisi
  • $1Boş dizeyi yakalayan ile eşleştirin ve değiştirin
• (_)+ : Yukarıdakilerin hiçbiriyle eşleşmeyen herhangi bir boşluk dizisi, yani ortada
  • $1Tek bir alanı yakalayan ile eşleştirin ve değiştirin

Ayrıca bakınız

• regular-expressions.info/Anchors

Tek ihtiyacınız olan:

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

burada bir veya daha fazla boşluğu eşleştirip bunları tek bir boşlukla değiştirip daha sonra boşlukları başlangıçta ve sonunda kırpabilirsiniz (birisinin işaret ettiği gibi regex'i daha hızlı hale getirmek için ilk kırparak ve ardından eşleştirerek tersine çevirebilirsiniz).

Bunu hızlı bir şekilde test etmek için şunu deneyin:

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

ve geri dönecek:

"hello there"

Apache ortak StringUtils.normalizeSpace(String str)yöntemini kullanın . Dokümanlara buradan bakın

Bu benim için mükemmel çalıştı: sValue = sValue.trim().replaceAll("\\s+", " ");

"[ ]{2,}"

Bu, birden fazla alanla eşleşecektir.

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

ÇIKTI:

hello there

Dizenin başında ve sonundaki boşlukları ortadan kaldırmak için String#trim()yöntemi kullanın . Ve sonra kullanın mytext.replaceAll("( )+", " ").

Önce String.trim()regex replace komutunu kullanabilir ve ardından sonuca uygulayabilirsiniz.

Aşağıdaki kod, kelimeler arasındaki boşlukları sıkıştırır ve dizenin başında ve sonunda bunları kaldırır

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

Bu çıktı a string with many spaces, a tab and a newline

Boşluklar, sekmeler ve yeni satırlar dahil yazdırılamayan karakterlerin sıkıştırılacağını veya kaldırılacağını unutmayın

Daha fazla bilgi için ilgili belgelere bakın:

• String # trim () yöntemi
• String # replaceAll (String regex, String replacement) yöntemi
• Java'nın normal ifade uygulaması hakkında bilgi için Pattern sınıfının belgelerine bakın

Bunu dene.

Basit kod

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

ÇIKTI

hello there

İlk olarak tüm boşlukları tek boşlukla değiştirecek. Biz kırpma yapmak gerekiyordu mu daha Stringçalıştırma nedeniyle Stringve End Stringeğer tek boşluk ile tüm alanı yerini alacak Stringait başlayarak boşlukları vardır Stringve sonu Stringonları kırpmak gerek Yani. Daha istediğiniz olsun String.

Lookaround'ları da kullanabilirsiniz.

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

VEYA

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

<space>(?= )bir boşluk karakteriyle ve ardından başka bir boşluk karakteriyle eşleşir. Birbirini izleyen uzaylarda, bir boşluk karakteri izlemediği için, son hariç tüm boşluklarla eşleşir. Bu, kaldırma işleminden sonra art arda boşluklar için size tek bir alan bırakır.

Misal:

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

) (Döşeme

Yalnızca önde gelen ve arkadaki boşlukları kaldırır.

Java Doc'tan "Değeri bu dize olan ve önde ve arkadaki boşluklar kaldırılmış bir dize döndürür."

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

"D ev Dum my"

replace (), replaceAll ()

Kelimedeki tüm boş dizelerin yerini alır,

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

Çıktı:

"DevDummy"

"DevDummy"

"DevDummy"

Not: "\ s +", boş boşluk karakterine benzer normal ifadedir.

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

Şimdiye kadar çok sayıda doğru cevap verildi ve çok sayıda upvotes görüyorum. Bununla birlikte, bahsedilen yollar işe yarayacak, ancak gerçekten optimize edilmemiş veya gerçekten okunamıyor. Kısa süre önce her geliştiricinin beğeneceği bir çözümle karşılaştım.

String nameWithProperSpacing = StringUtils.normalizeSpace( stringWithLotOfSpaces );

Bitirdiniz. Bu okunabilir bir çözümdür.

Kotlin'de şöyle görünecekti

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

String str = " hello world"

önce boşlukları azalt

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

ilk harfi büyük yaz ve diğer her şeyi küçük harfe çevirme

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

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

Bu benim için çalıştı

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

burada filtre işlevi takip eder ve tarama giriş dizesidir:

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

böyle yapmalısın

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

+ yuvarlak köşeli parantez içine koyun.

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

Bkz String.replaceAll.

Normal ifadeyi kullanın "\s"ve ile değiştirin " ".

Sonra kullanın String.trim.

şuna göz at...

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

} 

Dize yalnızca tek boşluk içeriyorsa, replace () değişmez,

Boşluklar birden fazla ise, replace () eylemi boşluk bırakma işlemini gerçekleştirir ve kaldırır.

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

Bir Dizedeki boşluk sayısını saymak için.

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

Desen .quote ("?") Değişmez desen Dizesi döndürür.

Ben daha iyi bir çözüm olarak regex kullanarak ikinci cevap bulmadan önce benim yöntem. Belki birisinin bu koda ihtiyacı vardır.

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

Akış sürümü, boşlukları ve sekmeleri filtreler.

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"

Dizenin herhangi bir yerinde beyaz boşluğu kaldırmak için en basit yöntem.

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

Yukarıdaki çözüm, herhangi bir java işlevi kullanmadan O (n) karmaşıklığına sahip algoritmadır.

Lütfen aşağıdaki kodu kullanın

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

Gecikme için üzgünüm! Aradığınız en iyi ve en verimli yanıtı aşağıda bulabilirsiniz:

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

Yani bu örneğin çıktısı şöyle olacak: Benim adım kingkon.

Ancak bu yöntem dizenizin sahip olabileceği "\ n" karakterini de kaldıracaktır. Yani bunu istemiyorsanız sadece bu basit yöntemi kullanın:

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

Ve öndeki ve arkadaki boşlukları da şeritlemek istiyorsanız ekleyin:

str = str.trim();

ReplaceAll yönteminin çok daha kolay olduğunu biliyorum ama bunu da göndermek istedim.

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

String Tokenizer kullanılabilir

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