Java - Schnellste Möglichkeit, um die Größe von String zu überprüfen

Question

Ich habe den folgenden Code innerhalb einer Schleife Anweisung.
In der Schleife werden Strings an sb (StringBuilder) angehängt und geprüft, ob die Größe von sb 5MB erreicht hat.

if (sb.toString().getBytes("UTF-8").length >= 5242880) { 
    // Do something 
} 

Dies funktioniert gut, aber es ist sehr langsam (in Bezug auf die Größe Prüfung)
Was ist der schnellste Weg, dies zu tun wäre?

Answer 1

Sie berechnen die UTF-8 Länge schnell

public static int utf8Length(CharSequence cs) { 
    return cs.codePoints() 
     .map(cp -> cp<=0x7ff? cp<=0x7f? 1: 2: cp<=0xffff? 3: 4) 
     .sum(); 
} 

mit der Wenn ASCII-Zeichen die Inhalte dominieren, könnte es etwas schneller zu bedienen

public static int utf8Length(CharSequence cs) { 
    return cs.length() 
     + cs.codePoints().filter(cp -> cp>0x7f).map(cp -> cp<=0x7ff? 1: 2).sum(); 
} 

statt.

Sie können aber auch das Optimierungspotenzial der nicht die gesamte Größe neu zu berechnen, sondern nur um die Größe des neuen Fragments betrachten Sie die StringBuilder sind Anfügen etwas gleich

StringBuilder sb = new StringBuilder(); 
    int length = 0; 
    for(…; …; …) { 
     String s = … //calculateNextString(); 
     sb.append(s); 
     length += utf8Length(s); 
     if(length >= 5242880) { 
      // Do something 

      // in case you're flushing the data: 
      sb.setLength(0); 
      length = 0; 
     } 
    } 

Dies setzt voraus, dass, wenn Sie‘ wenn Fragmente mit Ersatzpaaren angehängt werden, sind sie immer vollständig und nicht in ihre Hälften geteilt. Für normale Anwendungen sollte dies immer der Fall sein.

Eine weitere Möglichkeit, durch Didier-L vorgeschlagen, ist die Berechnung zu verschieben, bis Ihre StringBuilder eine Länge der durch drei geteilt Schwelle erreicht, nach wie vor, dass es unmöglich ist, eine UTF-8 Länge größer als die Schwelle zu haben. Dies wird jedoch nur dann von Vorteil sein, wenn Sie in einigen Ausführungen threshold/3 nicht erreichen.

Answer 2

Wenn Sie 1000 Mal eine Schleife ausführen, werden Sie 1000String generieren und dann in "UTF-8 Byte" -Array konvertieren, um die Länge zu erhalten.

Ich würde die Konvertierung durch Speichern der ersten Länge reduzieren. Erhalten Sie dann in jeder Schleife nur die Länge des hinzugefügten Werts, dann ist dies nur eine Addition.

int length = sb.toString().getBytes("UTF-8").length; 
for(String s : list){ 
    sb.append(s); 
    length += s.getBytes("UTF-8").length; 
    if(...){ 
    ... 
    } 
} 

Dies würde verwendet, um den Speicher reduzieren und die Herstellungskosten

Answer 3

Verwenden Sie einen ByteArrayOutputStream und einen OutputStreamWriter anstelle von StringBuilder. Verwenden Sie ByteArrayOutputStream.size(), um die Größe zu testen.