Java: используйте StringBuilder для вставки в начале

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).

вы можете использовать strbuilder.insert(0,i);

Может быть, я что-то упускаю, но вы хотите получить строку, которая выглядит так, "999897969594...543210", правильно?

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

В качестве альтернативного решения вы можете использовать структуру 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();

Этот поток довольно старый, но вы также можете подумать о рекурсивном решении, передающем 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));
        }
    }
}

У меня было подобное требование, когда я наткнулся на этот пост. Мне нужен быстрый способ построить строку, которая может расти с обеих сторон, т.е. добавлять новые буквы как спереди, так и сзади произвольно. Я знаю, что это старый пост, но он вдохновил меня попробовать несколько способов создания строк, и я решил поделиться своими выводами. Я также использую здесь некоторые конструкции Java 8, которые могли бы оптимизировать скорость в случаях 4 и 5.

https://gist.github.com/SidWagz/e41e836dec65ff24f78afdf8669e6420

В Gist выше есть подробный код, который может запустить любой. Я использовал несколько способов выращивания струн в этом; 1) Добавить к StringBuilder, 2) Вставить в начало StringBuilder, как показано @Mehrdad, 3) Частично вставить как с начала, так и с конца StringBuilder, 4) Использование списка для добавления с конца, 5) Использование Deque для добавить с лицевой стороны.

// 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, если необходимо иметь только строки длиной менее 90 тыс. символов (что все еще много), передняя вставка будет построить строку за то же время, что и для создания строки той же длины, добавив в конце. Я говорю о том, что штраф за время действительно имеет значение и является огромным, но только тогда, когда вам нужно построить действительно огромные цепочки. Можно использовать дек и соединить строки в конце, как показано в моем примере. Но StringBuilder немного более интуитивно понятен для чтения и кодирования, и штраф не будет иметь значения для меньших строк.

На самом деле производительность для случая 2 намного выше, чем для случая 1, чего я, кажется, не понимаю. Я предполагаю, что рост внутреннего буфера в StringBuilder будет одинаковым в случае переднего и заднего добавления. Я даже установил очень большую минимальную кучу, чтобы избежать задержки в росте кучи, если бы это сыграло свою роль. Может быть, кто-то, у кого есть лучшее понимание, может прокомментировать ниже.

Вы можете использовать метод вставки со смещением. поскольку смещение, установленное на «0», означает, что вы добавляете к началу вашего StringBuilder.

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

ПРИМЕЧАНИЕ: поскольку метод вставки принимает все типы примитивов, вы можете использовать для int, long, char[] и т. д.

Как насчет:

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

OR

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-документов:

Вставляет строковое представление аргумента Object в эту последовательность символов. Общий эффект такой же, как если бы второй аргумент был преобразован в строку методом String.valueOf(Object), а затем символы этой строки были вставлены в эту последовательность символов с указанным смещением.