问一个字符串的问题，谢谢大家

Question

我有个字符串，需要放很多空格，比如
String str=new String("                                              ");甚至比以上的还要多，总感觉不太好，请教大家有没有更好的办法放这些空格呢，谢谢

Answer 1

String.trim(str);用这个函数，细节再看看API

Answer 2

看错了 郁闷写一个比较多空格的String ,然后加起来 ，在加起来。
string str = new String("                       ");
String a = new String ();
for(int i = 0 ; i<100;i++){
    a += str; 
}看起来很可笑，不知道干什么啊。汗！！~~

Answer 3

StringBuffer str=new StringBuffer();写个循环追加就行了
str.append(" ");最后使用str.toString()转成String就行了.

Answer 4

string str = new String("                  "); 
String a = new String (); 
for(int i = 0 ; i <100;i++){ 
    str2 += str; 
} str2就是你想要的字符串

Answer 5

2楼的，我有点不同的见解哦，这样不是好办法哦，既然是很多空格相加的话，哪么就会产生很多中间的垃圾字符串常量，这样会浪费存储空间的，所以不应该用String，用的应该是StringBuffer才对。程序应该可以这样改：StringBuffer str = new StringBuffer(" "); 
for(int i = 0 ; i <100;i++){ 
    str.append("  "); 
}
String s = str.toString();最后得到的就是你想要的那个s了。

Answer 6

Write a function to solve this problem:public String blankString(int blankNum){
   String output = "";
   StringBuffer tempStr = ""
   
   for(int i=0; i<blankNum; i++)
      tempStr = tempStr.append(" ");   output = tempStr.toString();   return output;
}

Answer 7

用这个方法吧，这个要比用 StringBuffer 快一点public class Test1 {  
    
    public static void main(String[] args) {
        System.out.println("|" + generateSpace(5) + "|");
    }
    
    public static String generateSpace(int count) {
        if(count < 0) {
            throw new IllegalArgumentException("count must be great equal than 0.");
        }
        char[] chs = new char[count];
        for(int i = 0; i < count; i++) {
            chs[i] = ' ';
        }
        return new String(chs);
    }
}

Answer 8

使用StringBuffer循环插入，需要多少就添多少

Answer 9

用循环
想放几个就放几个
因为要不断的加
所以用StringBuffer

Answer 10

写个类来处理
class SpaceString
{
    int size;
    String orgString = null;    public SpaceString(String org,int size)
    {
        if (org == null)
        {
            orgString = "";
        }
        else
        {
            orgString = org;
        }
        this.size = size;
    }    public String toString()
    {
        StringBuffer sb = new StringBuffer(orgString);
        for (int i = 0; i < size; i++)
        {
            sb.append(' ');
        }
        return sb.toString();
    }
}

Answer 11

或者
final static String SPACES = "                       ";想要几个，直接SPACES.subString().

Answer 12

byte[] b = new byte[len];
System.arraycopy(str.getBytes(), 0, b, 0, str.getBytes().length);
return new String(b);

Answer 13

看来这个问题讨论的人挺多的，呵呵，做了个小实验以供进行性能比较：                        性能测试报告
                                                     （单位：纳秒）
+-----------+---------------+---------------+---------------+
|           |    char[]     | StringBuilder | StringBuffer  |
+-----+-----+---------------+---------------+---------------+
|     |  C  |    164934     |     217095    |    449021     |
|  A  +-----+---------------+---------------+---------------+
|     |  S  |      --       |     488630    |    670028     |
+-----+-----+---------------+---------------+---------------+
|     |  C  |      --       |     454022    |    616225     |
|  B  +-----+---------------+---------------+---------------+
|     |  S  |      --       |     703524    |    862583     |
+-----+-----+---------------+---------------+---------------+A -- 对容量进行初始化
B -- 未对容量进行初始化
C -- 采用 char 空格填充
S -- 采用 String 空格填充
测试代码循环 10000 次（用于对 JVM 进行预热）生成 10000 个字符长度的空格，求其平均数。
每种测试执行 5 次，取最小的输出时间。public class Test {
    
    public static void main(String[] args) {
        long t0, t1;
        String str = null;
        final int COUNT = 10000;
        t0 = System.nanoTime();
        for(int i = 0; i < COUNT; i++) {
            str = generateSpace(10000);
        }
        t1 = System.nanoTime();
        System.out.println((t1 - t0) / (float)COUNT);
        System.out.println(str.length());
    }
}
char[] A-C 组代码
public static String generateSpace(int count) {
    if(count < 0) {
        throw new IllegalArgumentException("count must be greater than or equal 0.");
    }
    char[] chs = new char[count];
    for(int i = 0; i < count; i++) {
        chs[i] = ' ';
    }
    return new String(chs);
}
StringBuilder A-C 组代码
StringBuilder 与 StringBuffer 的代码一致，A 代码与 B 代码一致，
只是 A 对其容量进行了初始化，而 B 代码没有进行初始。public static String generateSpace(int count) {
    if(count < 0) {
        throw new IllegalArgumentException("count must be greater than or equal 0.");
    }
    // A 组初始化时给定 count，B 组初始化时不给定 count
    StringBuilder sb = new StringBuilder(count);
    for(int i = 0; i < count; i++) {
        sb.append(' ');  // C 组使用字符空格，S 组使用字符串空格
    }
    return sb.toString();
}
结论从上面的测试结果可以看出，使有不同的方法生成空格的效率有很大的差别，以 char[] 的
执行速度最快。● StringBuilder 和 StringBuffer 两者由于同步的原因也有不小的差别。
● 由于生成的空格数量是已知的，对于 StringBuilder 和 StringBuffer 的影响是非常大的。
     执行速度相差在 50% 以上。
● append 添加空格时，对于空格的选择也很有讲究。空格属于单字符，采用 char 类型和 String
    执行速度相差也在 50% 以上。对于生成固定长度空格的方法选择来说，使用 char[], StringBuffer, StringBuilder 哪一种，
如选择后两者，如果容量是已经知的我们得选择对其容量进行初始化，如果是单字符时应采用 char 
进行 append。当然了，对于 StringBuffer, StingBuilder 来说，算法还可以再进行优化，比如：添加 10000 个
长度的空格的话，可以先添加 100 个生成一个字符串，然后再添加 100 次这个字符串，这时的效率会
有大幅度地提升（经实验 StringBuilder A-C 测试时间为 186928，比原来 217095 提升了 13% 的
速度）。由于生成的空格数量是不定的，在倍数选择以及非整数倍时需要精心地进行处理。