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

我有一个像这样的字符串：

mysz = "name=john age=13 year=2001";

我想删除字符串中的空格。我尝试了trim()，但是这只删除了整个字符串前后的空格。我也尝试过replaceAll("\W", "")，但是随后=也被删除了。

\\ W表示所有非单词，请参见download.oracle.com/javase/6/docs/api/java/util/regex / ...

您对“ name = johnage = 13year = 2001”字符串的计划是什么？我希望不要解析它。

@JonasElfström我想它可以帮助进行字符串比较

如果字符串实际是=“”呢？就像我提到的那样，trims（）所做的就是清除空字符串吗？ @zyamat吗？

如何删除Java字符串中的空白的可能重复项

#1 楼

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

st.replaceAll("\s+","")和st.replaceAll("\s","")产生相同的结果。比第一个快％，但是随着连续空格数的增加，第一个比第二个要好。

将值分配给变量，如果不直接使用的话： br />

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

我想指出的是，如果您要用单个空格（或某些其他字符集）替换所有空格，则这两个正则表达式将产生不同的结果。如果有连续的空格，请使用\\ s将每个空格字符替换为给定的给定字符。给定\\ s +，它将用单个替换字符串替换每组空白。我可以看到很多情况下，人们可能会来这篇帖子，用不仅仅是空字符串的东西替换空白，这可能会有所帮助。

–凯特琳
16-10-24在16:40

但是如果它在字符串的开头，它不会删除空格。

–寂寞
16-12-7在7:11

@lonesome为此使用.trim（）

– CQM
17年4月5日在21:01

只需使用apache-commons中的StringUtils。它是一个称为StringUtils.deleteWhitespace的静态方法。

–克罗泽塔
17年7月7日在13:48

@Gursel感谢两个正则表达式的答案和性能比较。我想知道为什么两者之间会有性能差异？有什么我想念的吗，请您指出任何有关性能差异的参考资料。

–Vishrant
18年2月17日在7:16

#2 楼

replaceAll("\s","")

\w =任何文字字符

\W =任何文字字符（包括标点符号等）

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

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

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

#3 楼

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

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

我只是从其他答案中改编了这段代码。我发布它的原因是，除了确切地是问题所要求的内容之外，它还表明结果以新字符串的形式返回，原始字符串未作某些暗示的修改。（经验丰富的Java开发人员可能会说“当然，您实际上不能修改String”，但是此问题的目标读者可能不知道。）

这是否意味着我们可以通过编写以下示例来覆盖原始字符串：S = S.replaceAll（“ \\ s”，“”）;而首先将完成替换，然后S将收到S的字符剥离版本

– frog豆
2014年1月1日17:57

@frogeyedpeas覆盖变量S，但不覆盖S指向的字符串。

–恢复莫妮卡
16年11月4日在19:42

拯救了我的一天！ ;）

–帕拉斯·in那（Paras Jain）
17年4月6日在2:56

#4 楼

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

迟到一分钟有何不同！

– HDave
13年6月7日，下午3:19

#5 楼

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

String withoutWhitespace = StringUtils.deleteWhitespace(whitespaces);

您可以在这里找到它。

#6 楼

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

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

这对于以下原因失败：“ ab c”

– Mohd Farid
16-4-15在10:29

@MohdFarid应用了一个修复程序，现在必须确定。

–丹尼斯·库拉金（Denis Kulagin）
16-11-22在16:51

我认为应该是st.replaceAll（“ [\\ s | \ u00A0] +”，“”）;

– paramupk
17年9月8日在2:49

#7 楼

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

欢迎有其他选择。他们将帮助某些人，即使不是所有人。

–james.garriss
2013年6月10日19:13

#8 楼

您应该使用

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

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

这样，它将在每个字符串之间使用多个空格。
上述正则表达式中的+号表示“一个或多个\ s”
-\ s =空格字符（包括空格，制表符等）。为什么我们这里需要s +？

我输入了一个简短的示例进行检查，因为这听起来很奇怪，发现不需要添加的加号。占用多个分隔单词的空格。原因很可能是replaceAll重复，直到模式与字符串的任何部分都不匹配为止。

– nyaray
13年7月16日在9:45

确实。 +可能会使它对CPU更加友好，因为连续的空格是在单个替换操作中处理的，但是在这种情况下，这是唯一的区别。确实是All，而不是+替换了字符串中非连续的空格。

–nitro2k01
13-10-18在4:45

它不会删除此（u00A0）

–Kerim FIRAT
19年5月5日在22:30

#9 楼

您已经从古瑟尔·科卡（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]);
    }
  }
}

输出：
name = john
age = 13
年= 2001

#10 楼

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

在输入字符串上使用静态方法“ StringUtils.deleteWhitespace(String str)”，它将在返回字符串删除所有空白。我尝试了您的示例字符串“ name=john age=13 year=2001”，它恰好返回了您想要的字符串-“ name=johnage=13year=2001”。希望这会有所帮助。

#11 楼

您可以通过

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

做到这一点

令人惊讶的是，在我这种情况下，唯一的工人。谢谢。

–Valeriy
19年8月15日在8:57

#12 楼

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

#13 楼

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

//在任何空格下都可以正常工作
*不要忘记字符串b中的空格

非常有用，但不能回答发布的问题！

– BuvinJ
16年6月10日在13:52

#14 楼

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

这个答案的其余部分在哪里？

– Lance E Sloan先生
13年6月7日在20:46

#15 楼

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

希望对您有帮助。

在您发布答案之前，其他年份已经提供了此信息。

– jan groth
2014年8月27日下午5:55

#16 楼

使用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);    
    }
}

#17 楼

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

上面有类似/等于您的建议的答案

– omerhakanbilici
17年9月15日在6:54

#18 楼

使用apache字符串util类最好避免NullPointerException

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

输出

abcdef

#19 楼

在Kotlin中使用st.replaceAll("\s+","")时，请确保使用正则表达式包装"\s+"：

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

#20 楼

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

第一个带空格，第二个带空格。

然后完成。

只是为了澄清，空格表示[\ t \ n \ x0B \ f \ r]。您只在做普通[]空间。

– GKFX
2015年2月11日在11:15

#21 楼

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

#22 楼

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

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

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

它很好用，而且易于理解。

但是解决方案效率很低。而且，正如您从其他解决方案中看到的那样-这仅适用于“”空间-不适用于不同种类的空白。

–GhostCat
17年8月1日在7:21

#23 楼

解决此问题的方法有很多。
您可以使用拆分函数或字符串的替换函数。 2015/10 / how-to-to-remove-spaces-from-given-string.html

#24 楼

字符串中还存在其他空格字符。因此，我们可能需要从字符串中替换空格字符。
这里是空格char的列表http://jkorpela.fi/chars/spaces.html

，因此我们需要将

\ u2004修改为三个-PER-EM SPACE

s.replaceAll（“ [\ u0020 \ u2004]”，“”）

#25 楼

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

结果：

@jahir的答案排在第一位

带有短文本的StringUtils：1.21E-4 ms（121.0 ms）
带有长文本的StringUtils：0.001648 ms（1648.0 ms）

第二名

带短文本的字符串生成器：2.48E-4 ms（248.0 ms）
带长文本的字符串生成器：0.00566 ms（5660.0 ms）

第三名

正则表达式短文本：8.36E-4 ms（836.0 ms）
正则表达式长文本：0.008877 ms（8877.0 ms）

第四名

短文本循环：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
                )
        );
    }
}

#26 楼

可以使用字符类中的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);
}

#27 楼

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

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

#28 楼

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

这可能有所帮助。

#29 楼

您还可以查看以下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";

#30 楼

private String generateAttachName(String fileName, String searchOn, String char1) {
    return fileName.replaceAll(searchOn, char1);
}


String fileName= generateAttachName("Hello My Mom","\s","");

编程黑洞网