blocks|key|689362|text|您可以使用strbuilder.insert(0,i);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|689363|entityMap^0|5|N|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

you can use <code>strbuilder.insert(0,i);</code>

blocks|key|905658|text|也许我漏掉了什么，但是你想要得到一个像这样的字符串，"999897969594...543210"，对吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|905659|StringBuilder+sb+=+new+StringBuilder();
for(int+i=99;i>=0;i--){
++++sb.append(String.valueOf(i));
}|code-block|syntax|javascript|905660|entityMap^0|Q|N|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Maybe I'm missing something but you want to wind up with a String that looks like this, <code>"999897969594...543210"</code>, correct?

<pre><code>StringBuilder sb = new StringBuilder();
for(int i=99;i&gt;=0;i--){
 sb.append(String.valueOf(i));
}
</code></pre>

blocks|key|905735|text|作为另一种解决方案，您可以使用后进先出结构(如堆栈)来存储所有字符串，完成后，只需将它们全部取出并放入StringBuilder。它自然地颠倒了放置在其中的项(字符串)的顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|905736|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();|code-block|syntax|javascript|905737|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As an alternative solution you can use a LIFO structure (like a stack) to store all the strings and when you are done just take them all out and put them into the StringBuilder. It naturally reverses the order of the items (strings) placed in it.

<pre><code>Stack&lt;String&gt; textStack = new Stack&lt;String&gt;();
// 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();
</code></pre>

blocks|key|905689|text|这个线程已经很老了，但您也可以考虑使用递归解决方案来传递StringBuilder进行填充。这允许防止任何反向处理等。只需使用递归设计您的迭代，并仔细决定退出条件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|905690|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+%2B+1);
++++++++++++sb.append(Integer.toString(index));
++++++++}
++++}
}|code-block|syntax|javascript|905691|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This thread is quite old, but you could also think about a recursive solution passing the StringBuilder to fill. This allows to prevent any reverse processing etc. Just need to design your iteration with a recursion and carefully decide for an exit condition.

<pre class="lang-java prettyprint-override"><code>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 &lt; limit) {
 doRecursive(sb, limit, index + 1);
 sb.append(Integer.toString(index));
 }
 }
}
</code></pre>

blocks|key|905819|text|当我偶然发现这篇文章时，我也有类似的要求。我想要一个快速的方法来建立一个字符串，可以从两边增长，即。在正面和背面随意添加新字母。我知道这是一个古老的帖子，但它启发了我尝试一些创建字符串的方法，我想我应该分享我的发现。我还在这里使用了一些Java+8构造，这可以优化情况4和5的速度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|905820|https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420|offset|length|905821|上面的要点提供了任何人都可以运行的详细代码。我在这里采取了几种方法来增加字符串:+1)附加到StringBuilder，2)插入到StringBuilder的前面，如@Mehrdad所示，3)从StringBuilder的前端和末尾部分插入，4)使用列表从end附加，5)使用Deque从前端附加。|905822|//+Case+2++++
StringBuilder+build3+=+new+StringBuilder();
IntStream.range(0,+MAX_STR)
++++++++++++++++++++.sequential()
++++++++++++++++++++.forEach(i+->+{
++++++++++++++++++++++++if+(i%252+==+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%252+==+0)+deque.addLast(Integer.toString(i));+else+deque.addFirst(Integer.toString(i));
++++++++++++++++});

String+dequeOut+=+deque.stream().collect(Collectors.joining(""));|code-block|syntax|javascript|905823|我将重点放在前面，仅附加案例。情况2和情况5。StringBuilder的实现在内部决定了内部缓冲区的增长方式，除了在前面追加的情况下将所有缓冲区从左向右移动之外，还限制了速度。虽然直接插入到StringBuilder前面所花费的时间会增长到非常高的值，如@Mehrdad所示，但如果需要只有长度小于90k个字符的字符串(这仍然很多)，则前面的插入将构建一个字符串，其时间与通过在末尾追加构建相同长度的字符串所需的时间相同。我要说的是，时间代价确实很大，但只有当你必须构建真正巨大的字符串时才会。如我的示例所示，您可以使用一个双队列并在末尾加入字符串。但是StringBuilder在阅读和编码方面更直观一些，而且对于较小的字符串来说，惩罚也无关紧要。|905824|实际上，第二种情况的性能比第一种情况快得多，这一点我似乎不太理解。我假设StringBuilder中内部缓冲区的增长在前面追加和后面追加的情况下是相同的。我甚至将最小堆设置为非常大的数量，以避免堆增长的延迟，如果这会起作用的话。也许有更好理解的人可以在下面发表评论。|905825|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1S|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|15|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|C]]]]

I had a similar requirement when I stumbled on this post. I wanted a fast way to build a String that can grow from both sides ie. add new letters on the front as well as back arbitrarily. I know this is an old post, but it inspired me to try out a few ways to create strings and I thought I'd share my findings. I am also using some Java 8 constructs in this, which could have optimised the speed in cases 4 and 5. 

<a href="https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420" rel="nofollow noreferrer">https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420</a>

The Gist above has the detailed code that anyone can run.
I took few ways of growing strings in this; 1) Append to StringBuilder, 2) Insert to front of StringBuilder as as shown by @Mehrdad, 3) Partially insert from front as well as end of the StringBuilder, 4) Using a list to append from end, 5) Using a Deque to append from the front.

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


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

String dequeOut = deque.stream().collect(Collectors.joining(""));
</code></pre>

I'll focus on the front append only cases ie. case 2 and case 5. The implementation of StringBuilder internally decides how the internal buffer grows, which apart from moving all buffer left to right in case of front appending limits the speed. While time taken when inserting directly to the front of the StringBuilder grows to really high values, as shown by @Mehrdad, if the need is to only have strings of length less than 90k characters (which is still a lot), the front insert will build a String in the same time as it would take to build a String of the same length by appending at the end. What I am saying is that time time penalty indeed kicks and is huge, but only when you have to build really huge strings. One could use a deque and join the strings at the end as shown in my example. But StringBuilder is a bit more intuitive to read and code, and the penalty would not matter for smaller strings.

Actually the performance for case 2 is much faster than case 1, which I don't seem to understand. I assume the growth for the internal buffer in StringBuilder would be the same in case of front append and back append. I even set the minimum heap to a very large amount to avoid delay in heap growth, if that would have played a role. Maybe someone who has a better understanding can comment below.

blocks|key|905836|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|905837|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

I could only do this with String, for example: 

<pre><code>String str="";
for(int i=0;i&lt;100;i++){
 str=i+str;
}
</code></pre>

Is there a way to achieve this with StringBuilder? Thanks.

java: use StringBuilder to insert at the beginning

Java

我只能使用字符串来做这件事，例如：String str="";for(int i=0;i<100;i++){ str=i+str;}有没有办法通过StringBuilder来实现这一点呢？谢谢。

问java:使用StringBuilder在开头插入
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问java:使用StringBuilder在开头插入EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问java:使用StringBuilder在开头插入
EN