Java: inserire una stringa in una posizione di indice dinamico in cui l’indice è una stringa formattata

Ho il formato di stringa come questo:

{a},{b2},{str},{5}... {a} - index[0], {b2} - index[1],(str} - index[2],{5} - index[3] ... 

questo potrebbe essere più di 20K o 25K indici. Anche sale a 1L.

Voglio inserire la stringa “{c3}” in qualsiasi posizione, è una dynamic (per ex 3) il risultato dovrebbe essere come questo

 {a},{b2},{str},{c3},{5} 

È un’operazione molto frequente, che non viene utilizzata nell’applicazione console. È per un’applicazione web oriented. Quindi qual è il modo migliore per gestire questo in Java?

Usando il metodo split, dobbiamo usare System.arraycopy per gestirlo. Per il lato delle prestazioni è un po ‘difficile.

Quindi, i pls mi suggeriscono come gestirlo in REGEX. Guidami anche se è il modo migliore per gestirlo o dirmi se c’è un modo migliore?


Grazie per la tua risposta rapida.

Sì, questo è uno dei modi per risolvere il mio problema.

Spiegherò chiaramente il mio problema.

Ho letto il contenuto del file dal filestore e finalmente ho ottenuto il contenuto in questo modo: {a}, {b2}, {str}, {5} …

In quella stringa devo inserire del contenuto in un particolare indice (l’indice è basato su {}), dopodiché deve essere memorizzato in archivio.

Leggere e scrivere non è un problema nel mio caso. Lo gestiremo.

L’inserimento dell’indice particellare è solo un problema. se il server è servito bene o no quando sta per colpire frequentemente

Altri dubbi:

Supponiamo che la stringa abbia più di 25K indici, in tal caso il ciclo while viene eseguito 25k volte.

L’inserimento è l’operazione frequente, può essere colpito più tardi 50 volte al minuto. (50 * 25 = 1250K)

Supponiamo che 25users entrino nello stesso server in quel caso se può essere utile?

Non so da che parte è meglio. Se il tuo modello è adatto al mio caso?

Per favore consigliami…

È ansible che l’espressione regolare sia effettivamente più lenta dell’analisi esplicita di ciò di cui hai bisogno. Anche l’espressione richiesta potrebbe essere un po ‘complessa. Ecco un’alternativa da considerare che non richiede un array di grandi dimensioni:

 String input = "{a},{b2},{str},{5}"; int insertPos = 3; String insertText = "{c3}"; StringBuilder sb = new StringBuilder(); int pos = 0; Scanner scanner = new Scanner(input).useDelimiter(","); while (scanner.hasNext()) { String next = scanner.next(); if (pos++ == insertPos) { sb.append(insertText); sb.append(','); } sb.append(next); sb.append(','); } sb.deleteCharAt(sb.length() - 1); // remove the last comma String output = sb.toString(); // output will be "{a},{b2},{str},{c3},{5}" 

Non sono sicuro di quale sia il tuo caso d’uso, tuttavia puoi adattarlo per gestire più inserti secondo necessità.

Modifica: ecco una versione che è 50 volte più veloce. Contiene stringhe con indici 50K ciascuna può elaborare stringhe di input di circa 100 K al minuto in un singolo thread su hardware tipico (quindi 5 miliardi di indici / minuto).

 String input = "{a},{b2},{str},{5}"; int insertPos = 3; String insertText = "{c3}"; String output = input + ","; // add temporary comma int index = 0; int pos = 0; while (index > -1) { if (pos == insertPos) { output = output.substring(0, index) + (pos == 0 ? insertText + "," : "," + insertText) + output.substring(index); } index = output.indexOf(',', index + 1); pos++; } output = output.substring(0, output.length() - 1); // remove last comma System.out.println(output); // output will be "{a},{b2},{str},{c3},{5}"