List per stringa, potete aiutare il refactoring questo metodo (piccolo)?

Question

Usiamo questo piccolo metodo di utilità. Ma noi non ci piace. Dal momento che non è molto importante (che funziona in ogni caso ...), l'abbiamo dimenticato.
Ma questo è brutto, perché dobbiamo passare attraverso l'intero array, solo per la conversione da Byte[] a byte[].
Sto cercando:

• di un modo per lanciare la Byte[] in byte[] senza passare attraverso di essa
• o per un metodo di utilità per la fusione in un elenco di stringa

public static String byteListToString(List<Byte> l, Charset charset) {
    if (l == null) {
        return "";
    }
    byte[] array = new byte[l.size()];
    int i = 0;
    for (Byte current : l) {
        array[i] = current;
        i++;
    }
    return new String(array, charset);
}

Answer 1

Il vostro metodo è praticamente l'unico modo per farlo. Si possono trovare una libreria esterna che fa tutto o parte di esso, ma sarà essenzialmente la stessa cosa.

Tuttavia, c'è una cosa che nel codice che è un potenziale problema: Quando si chiama new String(array), si utilizza la codifica piattaforma predefinita per convertire i byte a caratteri. La codifica piattaforma differisce tra il sistema operativo e le impostazioni internazionali - utilizzando è quasi sempre un errore in attesa di accadere. Dipende da dove si sta ottenendo quei byte da, ma la loro codifica dovrebbe essere specificato da qualche parte, passato come argomento al metodo e utilizzato per la conversione (utilizzando il costruttore String con un secondo parametro).

Answer 2

import org.apache.commons.lang.ArrayUtils;

...

Byte[] bytes = new Byte[l.size()];
l.toArray(bytes);

byte[] b =  ArrayUtils.toPrimitive(bytes);

Answer 3

senza alcuna libreria aggiuntiva (ad esempio Apache Commons) il metodo va bene

Answer 4

nit Minor:

if (l == null || l.isEmpty() ) {
    return "" ;
}

per evitare di creare stringhe vuote per le liste vuote.

Answer 5

Guava fornisce una serie di utili primitivi utilities , tra cui un class Bytes che rende questa e altre operazioni su collezioni di Bytes banali.

private static String toString(List<Byte> bytes) {
  return new String(Bytes.toArray(bytes), StandardCharsets.UTF_8);
}

Answer 6

Si potrebbe utilizzare java.nio e venire con qualcosa di simile

public static String byteListToString(List<Byte> l, Charset cs)
throws IOException
{
    final int CBUF_SIZE = 8;
    final int BBUF_SIZE = 8;

    CharBuffer cbuf = CharBuffer.allocate(CBUF_SIZE);
    char[] chArr = cbuf.array();
    ByteBuffer bbuf = ByteBuffer.allocate(BBUF_SIZE);
    CharsetDecoder dec = cs.newDecoder();
    StringWriter sw = new StringWriter((int)(l.size() * dec.averageCharsPerByte()));

    Iterator<Byte> itInput = l.iterator();
    int bytesRemaining = l.size();
    boolean finished = false;
    while (! finished)
    {
        // work out how much data we are likely to be able to read
        final int bPos = bbuf.position();
        final int bLim = bbuf.limit();
        int bSize = bLim-bPos;
        bSize = Math.min(bSize, bytesRemaining);
        while ((--bSize >= 0) && itInput.hasNext()) 
        {
            bbuf.put(itInput.next().byteValue());
            --bytesRemaining;
        }
        bbuf.flip();
        final int cStartPos = cbuf.position();
        CoderResult cr = dec.decode(bbuf, cbuf, (bytesRemaining <= 0));
        if (cr.isError()) cr.throwException();
        bbuf.compact();
        finished = (bytesRemaining <= 0) && (cr == CoderResult.UNDERFLOW);
        final int cEndPos = cbuf.position();
        final int cSize = cEndPos - cStartPos;
        sw.write(chArr, cStartPos, cSize);
        cbuf.clear();
    }
    return sw.toString();
}

ma io davvero non credo che mi consiglia per qualcosa di così semplice.

Answer 7

Una possibilità potrebbe essere quella di utilizzare StringBuilder:

public static String byteListToString(List<Byte> l) {
    if (l == null) {
        return "" ;
    }
    StringBuilder sb = new StringBuilder(l.size());

    for (Byte current : l) {
        sb.append((char)current);
    }

    return sb.toString();
}

In alternativa, se avete bisogno di conversione dei caratteri

public static String byteListToString(List<Byte> l) {
    if (l == null) {
        return "" ;
    }
    ByteArrayOutputStream bout = new ByteArrayOutputStream(l.size());

    for (Byte current : l) {
        bout.write(current);
    }

    return bout.toString("UTF-8");
}

Se state aggregare byte, provare ByteArrayOutputStream in primo luogo, invece di Lista di byte. Nota: Attenzione per l'UnsupportedEncodingException - avrete bisogno di try-catch da qualche parte

.

Answer 8

Controlla la BitConverter di classe, penso che fa quello che si vuole. Usalo in combinazione con il metodo List.toArray ().