java：使用StringBuilder在开头插入

Question

我只能用 String 来做到这一点，例如：

String str = "";
for (int i = 0; i < 100; i++) {
    str = i + str;
}

有没有办法用 StringBuilder 来实现这一点？谢谢。

Answer 1

// DO NOT DO THIS. It is quadratic-time!
StringBuilder sb = new StringBuilder();
for(int i=0;i<100;i++){
    sb.insert(0, Integer.toString(i));
}

警告： 它违背了 StringBuilder 的目的，但它执行了您所要求的操作。

---

更好的技术（尽管仍然不理想）：

1. 反转要插入的每个字符串。
2. 将每个字符串附加到StringBuilder。
3. 完成后，反转整个 StringBuilder。

这会将 O(n²) 解决方案变成 O(n)。

Answer 2

您可以使用strbuilder.insert(0,i);

Answer 3

也许我遗漏了一些东西，但你想得到一个看起来像这样的字符串，“999897969594...543210”，对吗？

StringBuilder sb = new StringBuilder();
for(int i=99;i>=0;i--){
    sb.append(String.valueOf(i));
}

Answer 4

作为替代解决方案，您可以使用 LIFO 结构（如堆栈）来存储所有字符串，完成后只需将它们全部取出并放入 StringBuilder 中。它自然会颠倒放置在其中的项目（字符串）的顺序。

Stack<String> textStack = new Stack<String>();
// push the strings to the stack
while(!isReadingTextDone()) {
    String text = readText();
    textStack.push(text);
}
// pop the strings and add to the text builder
String builder = new StringBuilder(); 
while (!textStack.empty()) {
      builder.append(textStack.pop());
}
// get the final string
String finalText =  builder.toString();

Answer 5

该线程相当古老，但您也可以考虑传递 StringBuilder 来填充的递归解决方案。这可以防止任何逆向处理等。只需使用递归设计迭代并仔细决定退出条件。

public class Test {

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        doRecursive(sb, 100, 0);
        System.out.println(sb.toString());
    }

    public static void doRecursive(StringBuilder sb, int limit, int index) {
        if (index < limit) {
            doRecursive(sb, limit, index + 1);
            sb.append(Integer.toString(index));
        }
    }
}

Answer 6

您可以使用带有偏移量的插入方法。
因为偏移量设置为“0”意味着您要附加到 StringBuilder 的前面。

StringBuilder sb = new StringBuilder();
for(int i=0;i<100;i++){
    sb.insert(0,i);
}

注意：
由于 insert 方法接受所有类型的基元，因此您可以使用 int、long、char[] 等。

Answer 7

当我偶然发现这篇文章时，我也有类似的要求。我想要一种快速的方法来构建可以从两侧生长的字符串，即。在正面和背面任意添加新字母。我知道这是一篇旧文章，但它激发了我尝试一些创建字符串的方法，我想我应该分享我的发现。我还在其中使用了一些 Java 8 构造，这可以优化案例 4 和 5 中的速度

。 noreferrer">https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420

上面的要点有任何人都可以运行的详细代码。
我在这方面采取了几种增长字符串的方法； 1）追加到 StringBuilder，2）插入到 StringBuilder 的前面，如 @Mehrdad 所示，3）从 StringBuilder 的前面和末尾部分插入，4）使用列表从末尾追加，5）使用双端队列从前面追加。

// Case 2    
StringBuilder build3 = new StringBuilder();
IntStream.range(0, MAX_STR)
                    .sequential()
                    .forEach(i -> {
                        if (i%2 == 0) build3.append(Integer.toString(i)); else build3.insert(0, Integer.toString(i));
                    });
String build3Out = build3.toString();


//Case 5
Deque<String> deque = new ArrayDeque<>();
IntStream.range(0, MAX_STR)
                .sequential()
                .forEach(i -> {
                    if (i%2 == 0) deque.addLast(Integer.toString(i)); else deque.addFirst(Integer.toString(i));
                });

String dequeOut = deque.stream().collect(Collectors.joining(""));

我将重点关注前面仅附加的情况，即。情况 2 和情况 5。 StringBuilder 的实现在内部决定内部缓冲区如何增长，除了在前面追加的情况下将所有缓冲区从左向右移动之外还限制了速度。虽然直接插入到 StringBuilder 前面所花费的时间会增长到非常高的值，如 @Mehrdad 所示，如果只需要长度小于 90k 个字符的字符串（这仍然很多），则前面的插入将构建一个字符串的时间与通过在末尾附加构建相同长度的字符串的时间相同。我想说的是，时间损失确实很大，但只有当你必须构建非常巨大的字符串时。可以使用双端队列并在末尾连接字符串，如我的示例所示。但 StringBuilder 的阅读和编码更加直观，而且对于较小的字符串来说，这种损失并不重要。

实际上，情况 2 的性能比情况 1 快得多，我似乎不明白。我假设 StringBuilder 中内部缓冲区的增长在前追加和后追加的情况下是相同的。我什至将最小堆设置为一个非常大的值，以避免延迟堆增长（如果这会发挥作用的话）。也许有更了解的人可以在下面评论。

Answer 8

Difference Between String, StringBuilder And StringBuffer Classes
String
String is immutable ( once created can not be changed )object. The object created as a
String is stored in the Constant String Pool.
Every immutable object in Java is thread-safe, which implies String is also thread-safe. String
can not be used by two threads simultaneously.
String once assigned can not be changed.
StringBuffer
StringBuffer is mutable means one can change the value of the object. The object created
through StringBuffer is stored in the heap. StringBuffer has the same methods as the
StringBuilder , but each method in StringBuffer is synchronized that is StringBuffer is thread
safe .
Due to this, it does not allow two threads to simultaneously access the same method. Each
method can be accessed by one thread at a time.
But being thread-safe has disadvantages too as the performance of the StringBuffer hits due
to thread-safe property. Thus StringBuilder is faster than the StringBuffer when calling the
same methods of each class.
String Buffer can be converted to the string by using
toString() method.

    StringBuffer demo1 = new StringBuffer("Hello") ;

// The above object stored in heap and its value can be changed.
/
// Above statement is right as it modifies the value which is allowed in the StringBuffer
StringBuilder
StringBuilder is the same as the StringBuffer, that is it stores the object in heap and it can also
be modified. The main difference between the StringBuffer and StringBuilder is
that StringBuilder is also not thread-safe.
StringBuilder is fast as it is not thread-safe.
/
// The above object is stored in the heap and its value can be modified
/
// Above statement is right as it modifies the value which is allowed in the StringBuilder

Answer 9

怎么样：

StringBuilder builder = new StringBuilder();
for(int i=99;i>=0;i--){
    builder.append(Integer.toString(i));
}
builder.toString();

或者

StringBuilder builder = new StringBuilder();
for(int i=0;i<100;i++){
  builder.insert(0, Integer.toString(i));
}
builder.toString();

但是有了这个，您将进行 O(N^2) 操作而不是 O(N)。

来自 java 文档的片段：

将对象参数的字符串表示形式插入到此中
字符序列。整体效果和第二个一模一样
参数通过方法转换为字符串
String.valueOf(Object)，然后该字符串的字符
插入到此字符序列中指定的偏移量处。