java: utilise SsortingngBuilder pour l’insérer au début

Je ne pouvais le faire qu’avec Ssortingng, par exemple:

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

Est-il possible d’y parvenir avec SsortingngBuilder? Merci.

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

Attention: Cela va à l' SsortingngBuilder du but de SsortingngBuilder , mais il fait ce que vous avez demandé.


Meilleure technique (bien que toujours pas idéale):

  1. Inverser chaque chaîne que vous souhaitez insérer.
  2. Ajoutez chaque chaîne à un SsortingngBuilder .
  3. Inverser le SsortingngBuilder complet lorsque vous avez terminé.

Cela transformera une solution de O (n²) en O ( n ).

vous pouvez utiliser strbuilder.insert(0,i);

Peut-être que je manque quelque chose mais que vous voulez vous retrouver avec une chaîne qui ressemble à ceci: "999897969594...543210" , "999897969594...543210" -ce pas?

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

En guise de solution alternative, vous pouvez utiliser une structure LIFO (comme une stack) pour stocker toutes les chaînes et, lorsque vous avez terminé, retirez-les toutes et mettez-les dans le SsortingngBuilder. Il inverse naturellement l’ordre des éléments (chaînes) qui y sont placés.

 Stack textStack = new Stack(); // push the ssortingngs to the stack while(!isReadingTextDone()) { Ssortingng text = readText(); textStack.push(text); } // pop the ssortingngs and add to the text builder Ssortingng builder = new SsortingngBuilder(); while (!textStack.empty()) { builder.append(textStack.pop()); } // get the final ssortingng Ssortingng finalText = builder.toSsortingng(); 

Ce thread est assez ancien, mais vous pouvez aussi penser à une solution récursive en passant le SsortingngBuilder à remplir. Cela permet d’éviter tout traitement inverse, etc. Il vous suffit de concevoir votre itération avec une récursivité et de choisir soigneusement une condition de sortie.

 public class Test { public static void main(Ssortingng[] args) { SsortingngBuilder sb = new SsortingngBuilder(); doRecursive(sb, 100, 0); System.out.println(sb.toSsortingng()); } public static void doRecursive(SsortingngBuilder sb, int limit, int index) { if (index < limit) { doRecursive(sb, limit, index + 1); sb.append(Integer.toString(index)); } } } 

J’ai eu une exigence similaire quand je suis tombé sur ce post. Je voulais un moyen rapide de construire une chaîne pouvant évoluer des deux côtés, c.-à-d. append de nouvelles lettres au recto et au verso arbitrairement. Je sais que c’est un ancien message, mais cela m’a inspiré à essayer quelques manières de créer des chaînes et j’ai pensé partager mes découvertes. J’utilise aussi des constructions Java 8, ce qui aurait pu optimiser la vitesse dans les cas 4 et 5.

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

La liste ci-dessus contient le code détaillé que tout le monde peut exécuter. J’ai pris quelques moyens de faire pousser des ficelles en cela; 1) Ajouter à SsortingngBuilder, 2) Insérer devant SsortingngBuilder comme indiqué par @Mehrdad, 3) Insérer partiellement à partir du recto et de la fin du SsortingngBuilder, 4) Utiliser une liste à append de la fin, 5) Utiliser un Deque pour append de l’avant.

 // Case 2 SsortingngBuilder build3 = new SsortingngBuilder(); IntStream.range(0, MAX_STR) .sequential() .forEach(i -> { if (i%2 == 0) build3.append(Integer.toSsortingng(i)); else build3.insert(0, Integer.toSsortingng(i)); }); Ssortingng build3Out = build3.toSsortingng(); //Case 5 Deque deque = new ArrayDeque<>(); IntStream.range(0, MAX_STR) .sequential() .forEach(i -> { if (i%2 == 0) deque.addLast(Integer.toSsortingng(i)); else deque.addFirst(Integer.toSsortingng(i)); }); Ssortingng dequeOut = deque.stream().collect(Collectors.joining("")); 

Je vais me concentrer sur les cas de la première annexe seulement. cas 2 et cas 5. L’implémentation de SsortingngBuilder décide en interne de la manière dont le tampon interne se développe, ce qui, en plus de déplacer tous les tampons de gauche à droite en cas d’ajout de front, limite la vitesse. Alors que le temps nécessaire à l’insertion directe au début de SsortingngBuilder atteint des valeurs très élevées, comme le montre @Mehrdad, si le besoin ne comporte que des chaînes de moins de 90k caractères (ce qui est encore beaucoup), l’insertion avant sera construire une chaîne en même temps qu’il faudrait pour créer une chaîne de même longueur en ajoutant à la fin. Ce que je dis, c’est que la pénalité de temps passe vraiment et est énorme, mais seulement lorsque vous devez créer de très grosses chaînes. On pourrait utiliser un deque et joindre les cordes à la fin comme indiqué dans mon exemple. Mais SsortingngBuilder est un peu plus intuitif à lire et à coder, et la pénalité n’aurait aucune importance pour les petites chaînes.

En fait, la performance pour le cas 2 est beaucoup plus rapide que le cas 1, que je ne comprends pas. Je suppose que la croissance du tampon interne dans SsortingngBuilder serait la même en cas d’ajout avant et de retour. J’ai même mis le tas au minimum pour éviter un retard dans la croissance du tas, si cela avait joué un rôle. Peut-être que quelqu’un qui a une meilleure compréhension peut commenter ci-dessous.