Crear StringBuilder desde el byte []

Question

¿Hay alguna manera de crear un StringBuilder desde un byte[]?

quiero mejorar el uso de memoria usando StringBuilder pero lo que tengo es una primera byte[], así que tengo que crear un String del byte[] y luego crear el StringBuilder del String y yo no veo esto como solución óptima.

Gracias

Answer 1

Básicamente, su mejor opción parece estar usando CharsetDecoder directamente.

Así es como:

byte[] srcBytes = getYourSrcBytes(); 

//Whatever charset your bytes are endoded in 
Charset charset = Charset.forName("UTF-8"); 
CharsetDecoder decoder = charset.newDecoder(); 

//ByteBuffer.wrap simply wraps the byte array, it does not allocate new memory for it 
ByteBuffer srcBuffer = ByteBuffer.wrap(srcBytes); 
//Now, we decode our srcBuffer into a new CharBuffer (yes, new memory allocated here, no can do) 
CharBuffer resBuffer = decoder.decode(srcBuffer); 

//CharBuffer implements CharSequence interface, which StringBuilder fully support in it's methods 
StringBuilder yourStringBuilder = new StringBuilder(resBuffer); 

añadido:

Después de algunas pruebas, parece que el simple new String(bytes) es mucho más rápido y parece que no hay una forma sencilla de hacerlo más rápido que eso. Aquí está la prueba me encontré:

import java.io.IOException; 
import java.io.UnsupportedEncodingException; 
import java.nio.ByteBuffer; 
import java.nio.CharBuffer; 
import java.nio.charset.CharacterCodingException; 
import java.nio.charset.Charset; 
import java.nio.charset.CharsetDecoder; 
import java.text.ParseException; 

public class ConsoleMain { 
    public static void main(String[] args) throws IOException, ParseException { 
     StringBuilder sb1 = new StringBuilder("abcdefghijklmnopqrstuvwxyz"); 
     for (int i=0;i<19;i++) { 
      sb1.append(sb1); 
     } 
     System.out.println("Size of buffer: "+sb1.length()); 
     byte[] src = sb1.toString().getBytes("UTF-8"); 
     StringBuilder res; 

     long startTime = System.currentTimeMillis(); 
     res = testStringConvert(src); 
     System.out.println("Conversion using String time (msec): "+(System.currentTimeMillis()-startTime)); 
     if (!res.toString().equals(sb1.toString())) { 
      System.err.println("Conversion error"); 
     } 

     startTime = System.currentTimeMillis(); 
     res = testCBConvert(src); 
     System.out.println("Conversion using CharBuffer time (msec): "+(System.currentTimeMillis()-startTime)); 
     if (!res.toString().equals(sb1.toString())) { 
      System.err.println("Conversion error"); 
     } 
    } 

    private static StringBuilder testStringConvert(byte[] src) throws UnsupportedEncodingException { 
     String s = new String(src, "UTF-8"); 
     StringBuilder b = new StringBuilder(s); 
     return b; 
    } 

    private static StringBuilder testCBConvert(byte[] src) throws CharacterCodingException { 
     Charset charset = Charset.forName("UTF-8"); 
     CharsetDecoder decoder = charset.newDecoder(); 
     ByteBuffer srcBuffer = ByteBuffer.wrap(src); 
     CharBuffer resBuffer = decoder.decode(srcBuffer); 
     StringBuilder b = new StringBuilder(resBuffer); 
     return b; 
    } 
} 

Resultados:

Size of buffer: 13631488 
Conversion using String time (msec): 91 
Conversion using CharBuffer time (msec): 252 

y A (menos memoria que consume) versión modificada por Ideone: Here.

Answer 2

Si son enunciados cortos los que desea, no hay forma de evitar el paso de String en el medio. El constructor String mezcla la conversión y la construcción de objetos para mayor comodidad en un caso muy común, pero no existe un constructor de conveniencia para StringBuilder.

Si se trata de rendimiento le interesa, entonces es posible que evite el objeto de cadena intermedia mediante el uso de algo como esto:

new StringBuilder(Charset.forName(charsetName).decode(ByteBuffer.wrap(inBytes))) 

Si usted quiere ser capaz de ajustar el rendimiento, se puede controlar el decodificar el proceso usted mismo. Por ejemplo, es posible que desee evitar el uso de demasiada memoria, utilizando averageCharsPerByte como una estimación de la cantidad de memoria que se necesitará. En lugar de cambiar el tamaño del búfer si ese cálculo era demasiado corto, podría usar el StringBuilder resultante para acumular todas las partes.

CharsetDecoder cd = Charset.forName(charsetName).newDecoder(); 
cd.onMalformedInput(CodingErrorAction.REPLACE); 
cd.onUnmappableCharacter(CodingErrorAction.REPLACE); 
int lengthEstimate = Math.ceil(cd.averageCharsPerByte()*inBytes.length) + 1; 
ByteBuffer inBuf = ByteBuffer.wrap(inBytes); 
CharBuffer outBuf = CharBuffer.allocate(lengthEstimate); 
StringBuilder out = new StringBuilder(lengthEstimate); 
CoderResult cr; 
while (true) { 
    cr = cd.decode(inBuf, outBuf, true); 
    out.append(outBuf); 
    outBuf.clear(); 
    if (cr.isUnderflow()) break; 
    if (!cr.isOverflow()) cr.throwException(); 
} 
cr = cd.flush(outBuf); 
if (!cr.isUnderflow()) cr.throwException(); 
out.append(outBuf); 

Sin embargo, dudo que el código anterior valga la pena en la mayoría de las aplicaciones. Si una aplicación está interesada en el rendimiento, probablemente no debería tratar con StringBuilder tampoco, pero maneja todo a nivel del búfer.