从Java中的字符串中删除空格

st.replaceAll("\\s+","") 删除所有空格和不可见字符（例如制表符、\n）。

st.replaceAll("\\s+","") 和 st.replaceAll("\\s","") 产生相同的结果。

第二个正则表达式比第一个快 20%，但随着连续空格数的增加，第一个比第二个执行得更好。

将值分配给变量，如果不直接使用：

st = st.replaceAll("\\s+","")

---

replaceAll("\\s","")

\w = 任何单词字符

\W = 任何非单词字符（包括标点符号等）

\s = 任何空格字符（包括空格、制表符等）

\S = 任何非空格字符（包括字母和数字，以及标点符号等）

（编辑：正如所指出的，如果您希望 \s 到达正则表达式引擎，则需要转义反斜杠，从而产生 \\s。）

---

这个问题最正确的答案是：

String mysz2 = mysz.replaceAll("\\s","");

我只是从其他答案中改编了这段代码。我发布它是因为除了正是问题所要求的之外，它还表明结果作为新字符串返回，原始字符串没有像某些答案暗示的那样被修改。

（有经验的 Java 开发人员可能会说“当然，你不能真正修改字符串”，但这个问题的目标受众很可能不知道这一点。）

---

replaceAll("\\s", "")怎么样。请参阅here。

---

处理字符串操作的一种方法是来自 Apache commons 的 StringUtils。

String withoutWhitespace = StringUtils.deleteWhitespace(whitespaces);

您可以找到它here。 commons-lang 包含更多内容并且得到很好的支持。

---

如果您还需要删除牢不可破的空格，您可以像这样升级您的代码：

st.replaceAll("[\\s|\\u00A0]+", "");

---

你应该使用

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

代替：

s.replaceAll("\\s", "");

这样，它将在每个字符串之间使用多个空格。上述正则表达式中的 + 符号表示“一个或多个 \s”

--\s = 任何空格字符（包括空格、制表符等）。为什么我们在这里需要 s+？

---

如果您更喜欢实用程序类而不是正则表达式，那么 Spring 框架的 StringUtils 中有一个方法 trimAllWhitespace(String)。

---

您已经从 Gursel Koca 那里得到了正确的答案，但我相信这很可能不是您真正想做的。如何改为解析键值？

import java.util.Enumeration;
import java.util.Hashtable;

class SplitIt {
  public static void main(String args[])  {

    String person = "name=john age=13 year=2001";

    for (String p : person.split("\\s")) {
      String[] keyValue = p.split("=");
      System.out.println(keyValue[0] + " = " + keyValue[1]);
    }
  }
}

输出：姓名 = 约翰年龄 = 13 年 = 2001

---

最简单的方法是使用 commons-lang3 库的 org.apache.commons.lang3.StringUtils 类，例如“commons-lang3-3.1.jar”。

在输入字符串 & 上使用静态方法“StringUtils.deleteWhitespace(String str)”删除所有空格后，它将返回一个字符串。我试过你的示例字符串 "name=john age=13 year=2001" &它返回给我的正是你想要的字符串——“name=johnage=13year=2001”。希望这可以帮助。

---

你可以这样做

String newMysz = mysz.replace(" ","");

---

public static void main(String[] args) {        
    String s = "name=john age=13 year=2001";
    String t = s.replaceAll(" ", "");
    System.out.println("s: " + s + ", t: " + t);
}

Output:
s: name=john age=13 year=2001, t: name=johnage=13year=2001

---

我正在尝试一个聚合答案，我在其中测试删除字符串中所有空格的所有方法。每种方法运行 100 万次，然后取平均值。注意：一些计算将用于汇总所有运行。

结果：

@jahir 's answer 第一名

带有短文本的 StringUtils：1.21E-4 毫秒（121.0 毫秒）

带有长文本的 StringUtils：0.001648 毫秒（1648.0 毫秒）

第二名

带有短文本的字符串生成器：2.48E-4 ms (248.0 ms)

长文本字符串生成器：0.00566 ms (5660.0 ms)

第三名

带有短文本的正则表达式：8.36E-4 ms (836.0 ms)

带有长文本的正则表达式：0.008877 毫秒（8877.0 毫秒）

第 4 名

短文本循环：0.001666 ms (1666.0 ms)

对于长文本循环：0.086437 ms (86437.0 ms)

这是代码：

public class RemoveAllWhitespaces {
    public static String Regex(String text){
        return text.replaceAll("\\s+", "");
    }

    public static String ForLoop(String text) {
        for (int i = text.length() - 1; i >= 0; i--) {
            if(Character.isWhitespace(text.codePointAt(i))) {
                text = text.substring(0, i) + text.substring(i + 1);
            }
        }

        return text;
    }

    public static String StringBuilder(String text){
        StringBuilder builder = new StringBuilder(text);
        for (int i = text.length() - 1; i >= 0; i--) {
            if(Character.isWhitespace(text.codePointAt(i))) {
                builder.deleteCharAt(i);
            }
        }

        return builder.toString();
    }
}

以下是测试：

import org.junit.jupiter.api.Test;

import java.util.function.Function;
import java.util.stream.IntStream;

import static org.junit.jupiter.api.Assertions.*;

public class RemoveAllWhitespacesTest {
    private static final String longText = "123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222";
    private static final String expected = "1231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc222";

    private static final String shortText = "123 123 \t 1adc \n 222";
    private static final String expectedShortText = "1231231adc222";

    private static final int numberOfIterations = 1000000;

    @Test
    public void Regex_LongText(){
        RunTest("Regex_LongText", text -> RemoveAllWhitespaces.Regex(text), longText, expected);
    }

    @Test
    public void Regex_ShortText(){
        RunTest("Regex_LongText", text -> RemoveAllWhitespaces.Regex(text), shortText, expectedShortText);

    }

    @Test
    public void For_LongText(){
        RunTest("For_LongText", text -> RemoveAllWhitespaces.ForLoop(text), longText, expected);
    }

    @Test
    public void For_ShortText(){
        RunTest("For_LongText", text -> RemoveAllWhitespaces.ForLoop(text), shortText, expectedShortText);
    }

    @Test
    public void StringBuilder_LongText(){
        RunTest("StringBuilder_LongText", text -> RemoveAllWhitespaces.StringBuilder(text), longText, expected);
    }

    @Test
    public void StringBuilder_ShortText(){
        RunTest("StringBuilder_ShortText", text -> RemoveAllWhitespaces.StringBuilder(text), shortText, expectedShortText);
    }

    private void RunTest(String testName, Function<String,String> func, String input, String expected){
        long startTime = System.currentTimeMillis();
        IntStream.range(0, numberOfIterations)
                .forEach(x -> assertEquals(expected, func.apply(input)));
        double totalMilliseconds = (double)System.currentTimeMillis() - (double)startTime;
        System.out.println(
                String.format(
                        "%s: %s ms (%s ms)",
                        testName,
                        totalMilliseconds / (double)numberOfIterations,
                        totalMilliseconds
                )
        );
    }
}

---

mysz = mysz.replace(" ","");

第一个有空间，第二个没有空间。

然后就完成了。

---

String a="string with                multi spaces ";
//or this 
String b= a.replaceAll("\\s+"," ");
String c= a.replace("    "," ").replace("   "," ").replace("  "," ").replace("   "," ").replace("  "," ");

//它适用于任何空格*不要忘记sting b中的空格

---

使用mysz.replaceAll("\\s+","");

---

使用 apache string util 类更好地避免 NullPointerException

org.apache.commons.lang3.StringUtils.replace("abc def ", " ", "")

输出

abcdef

---

\W 表示“非单词字符”。空白字符的模式是 \s。这在 Pattern javadoc 中有详细记录。

---

在java中我们可以做以下操作：

String pattern="[\\s]";
String replace="";
part="name=john age=13 year=2001";
Pattern p=Pattern.compile(pattern);
Matcher m=p.matcher(part);
part=m.replaceAll(replace);
System.out.println(part);

为此，您需要将以下包导入您的程序：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

我希望它会帮助你。

---

使用 Pattern And Matcher 更加动态。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RemovingSpace {

    /**
     * @param args
     * Removing Space Using Matcher
     */
    public static void main(String[] args) {
        String str= "jld fdkjg jfdg ";
        String pattern="[\\s]";
        String replace="";

        Pattern p= Pattern.compile(pattern);
        Matcher m=p.matcher(str);

        str=m.replaceAll(replace);
        System.out.println(str);    
    }
}

---

在 Kotlin 中使用 st.replaceAll("\\s+","") 时，请确保使用 Regex 包装 "\\s+"：

"myString".replace(Regex("\\s+"), "")

---

import java.util.*;
public class RemoveSpace {
    public static void main(String[] args) {
        String mysz = "name=john age=13 year=2001";
        Scanner scan = new Scanner(mysz);

        String result = "";
        while(scan.hasNext()) {
            result += scan.next();
        }
        System.out.println(result);
    }
}

---

要删除示例中的空格，这是另一种方法：

String mysz = "name=john age=13 year=2001";
String[] test = mysz.split(" ");
mysz = String.join("", mysz);

它的作用是将其转换为以空格为分隔符的数组，然后将数组中的项目组合在一起而没有空格。

它工作得很好，很容易理解。

---

有很多方法可以解决这个问题。您可以使用字符串的拆分功能或替换功能。

欲了解更多信息，请参阅 smilliar 问题 http://techno-terminal.blogspot.in/2015/10/how-to-remove-spaces-from-given-string.html

---

字符串中也存在其他空格字符。因此，我们可能需要从字符串中替换空格字符。

例如：NO-BREAK SPACE、3-PER-EM SPACE、PUNCTUATION SPACE

这是空格字符 http://jkorpela.fi/chars/spaces.html 的列表

所以我们需要修改

\u2004 我们为每个 EM 空间提供三个

s.replaceAll("[\u0020\u2004]","")

---

package com.sanjayacchana.challangingprograms;

public class RemoveAllWhiteSpacesInString {

    public static void main(String[] args) {
        
        String str = "name=john age=13 year=2001";
        
        str = str.replaceAll("\\s", ""); 
        
        System.out.println(str);
        
        
    }

}

---

可以使用 Character Class 中的 isWhitespace 函数删除空格。

public static void main(String[] args) {
    String withSpace = "Remove white space from line";
    StringBuilder removeSpace = new StringBuilder();

    for (int i = 0; i<withSpace.length();i++){
        if(!Character.isWhitespace(withSpace.charAt(i))){
            removeSpace=removeSpace.append(withSpace.charAt(i));
        }
    }
    System.out.println(removeSpace);
}

---

将每组文本分成自己的子字符串，然后连接这些子字符串：

public Address(String street, String city, String state, String zip ) {
    this.street = street;
    this.city = city;
    // Now checking to make sure that state has no spaces...
    int position = state.indexOf(" ");
    if(position >=0) {
        //now putting state back together if it has spaces...
        state = state.substring(0, position) + state.substring(position + 1);  
    }
}

---

public static String removeWhiteSpaces(String str){
    String s = "";
    char[] arr = str.toCharArray();
    for (int i = 0; i < arr.length; i++) {
        int temp = arr[i];
        if(temp != 32 && temp != 9) { // 32 ASCII for space and 9 is for Tab
            s += arr[i];
        }
    }
    return s;
}

这可能会有所帮助。

---

您还可以查看下面的 Java 代码。以下代码不使用任何“内置”方法。

/**
 * Remove all characters from an alphanumeric string.
 */
public class RemoveCharFromAlphanumerics {

    public static void main(String[] args) {

        String inp = "01239Debashish123Pattn456aik";

        char[] out = inp.toCharArray();

        int totint=0;

        for (int i = 0; i < out.length; i++) {
            System.out.println(out[i] + " : " + (int) out[i]);
            if ((int) out[i] >= 65 && (int) out[i] <= 122) {
                out[i] = ' ';
            }
            else {
                totint+=1;
            }

        }

        System.out.println(String.valueOf(out));
        System.out.println(String.valueOf("Length: "+ out.length));

        for (int c=0; c<out.length; c++){

            System.out.println(out[c] + " : " + (int) out[c]);

            if ( (int) out[c] == 32) {
                System.out.println("Its Blank");
                 out[c] = '\'';
            }

        }

        System.out.println(String.valueOf(out));

        System.out.println("**********");
        System.out.println("**********");
        char[] whitespace = new char[totint];
        int t=0;
        for (int d=0; d< out.length; d++) {

            int fst =32;



            if ((int) out[d] >= 48 && (int) out[d] <=57 ) {

                System.out.println(out[d]);
                whitespace[t]= out[d];
                t+=1;

            }

        }

        System.out.println("**********");
        System.out.println("**********");

        System.out.println("The String is: " + String.valueOf(whitespace));

    }
}

输入：

String inp = "01239Debashish123Pattn456aik";

输出：

The String is: 01239123456

---