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

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

74 голосов
/ 09 мая 2011

Я мог сделать это только со строкой, например: 

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

Есть ли способ достичь этого с помощью StringBuilder? Спасибо.

Ответы [ 6 ]

159 голосов
/ 09 мая 2011 
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 ).

27 голосов
/ 09 мая 2011

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

11 голосов
/ 09 мая 2011

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

StringBuilder sb = new StringBuilder();
for(int i=99;i>=0;i--){
    sb.append(String.valueOf(i));
}
6 голосов
/ 08 января 2015

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

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

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

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

...