ByteBuffer de Java a cadena

¿Es este un enfoque correcto para convertir ByteBuffer en String de esta manera?

String k = "abcd";
ByteBuffer b = ByteBuffer.wrap(k.getBytes());
String v = new String(b.array());

if(k.equals(v))
    System.out.println("it worked");
else
    System.out.println("did not work");

La razón por la que pregunto es que esto parece demasiado simple, mientras que otros enfoques como Java: Convertir cadenas desde y hacia ByteBuffer y los problemas asociados parecen más complejos.

EDITAR (2018): La respuesta de hermanos editada por @xinyongCheng es un enfoque más simple y debería ser la respuesta aceptada.

Su enfoque sería razonable si supiera que los bytes están en el juego de caracteres predeterminado de la plataforma. En su ejemplo, esto es cierto porquek.getBytes() devuelve los bytes en el juego de caracteres predeterminado de la plataforma.

Con más frecuencia, querrá especificar la codificación. Sin embargo, hay una forma más sencilla de hacerlo que la pregunta que vinculó. La API de cadena proporciona métodos que convierten entre una cadena y una matriz de bytes [] en una codificación particular. Estos métodos sugieren usar CharsetEncoder / CharsetDecoder "cuando se requiere más control sobre el proceso de decodificación [codificación]".

Para obtener los bytes de una cadena en una codificación particular, puede usar un método hermano getBytes ():

byte[] bytes = k.getBytes( StandardCharsets.UTF_8 );

Para poner bytes con una codificación particular en una cadena, puede usar un constructor de cadena diferente:

String v = new String( bytes, StandardCharsets.UTF_8 );

Tenga en cuenta que ByteBuffer.array()es una operación opcional. Si ha construido su ByteBuffer con una matriz, puede usar esa matriz directamente. De lo contrario, si desea estar seguro, use ByteBuffer.get(byte[] dst, int offset, int length)para obtener bytes del búfer en una matriz de bytes.

Hay un enfoque más simple para decodificar un ByteBufferen un Stringsin ningún problema, mencionado por Andy Thomas.

String s = StandardCharsets.UTF_8.decode(byteBuffer).toString();

Prueba esto:

new String(bytebuffer.array(), "ASCII");

NÓTESE BIEN. no puede convertir correctamente una matriz de bytes en una cadena sin conocer su codificación.

espero que esto ayude

Solo quería señalar que no es seguro asumir que ByteBuffer.array () siempre funcionará.

byte[] bytes;
if(buffer.hasArray()) {
    bytes = buffer.array();
} else {
    bytes = new byte[buffer.remaining()];
    buffer.get(bytes);
}
String v = new String(bytes, charset);

Por lo general, buffer.hasArray () siempre será verdadero o falso dependiendo de su caso de uso. En la práctica, a menos que realmente desee que funcione bajo cualquier circunstancia, es seguro optimizar la rama que no necesita. Pero es posible que el resto de las respuestas no funcionen con un ByteBuffer creado mediante ByteBuffer.allocateDirect ().

Las respuestas que se refieren a simplemente llamar array()no son del todo correctas: cuando el búfer se ha consumido parcialmente o se refiere a una parte de una matriz (puede ByteBuffer.wrapuna matriz en un desplazamiento dado, no necesariamente desde el principio), tenemos que tener en cuenta eso en nuestros cálculos. Esta es la solución general que funciona para búferes en todos los casos (no cubre la codificación):

if (myByteBuffer.hasArray()) {
    return new String(myByteBuffer.array(),
        myByteBuffer.arrayOffset() + myByteBuffer.position(),
        myByteBuffer.remaining());
} else {
    final byte[] b = new byte[myByteBuffer.remaining()];
    myByteBuffer.duplicate().get(b);
    return new String(b);
}

Para las preocupaciones relacionadas con la codificación, consulte la respuesta de Andy Thomas.

Tenga en cuenta (aparte del problema de codificación) que algunos de los códigos más complicados vinculados se toman la molestia de obtener la parte "activa" del ByteBuffer en cuestión (por ejemplo, usando la posición y el límite), en lugar de simplemente codificar todos los bytes en toda la matriz de respaldo (como lo hacen muchos de los ejemplos en estas respuestas).

Convierta una cadena en ByteBuffer, luego de ByteBuffer de nuevo a String usando Java:

import java.nio.charset.Charset;
import java.nio.*;

String babel = "obufscate thdé alphebat and yolo!!";
System.out.println(babel);
//Convert string to ByteBuffer:
ByteBuffer babb = Charset.forName("UTF-8").encode(babel);
try{
    //Convert ByteBuffer to String
    System.out.println(new String(babb.array(), "UTF-8"));
}
catch(Exception e){
    e.printStackTrace();
}

Que imprime la cadena desnuda impresa primero, y luego el ByteBuffer convertido en array ():

obufscate thdé alphebat and yolo!!
obufscate thdé alphebat and yolo!!

También esto fue útil para mí, reducir la cadena a bytes primitivos puede ayudar a inspeccionar lo que está sucediendo:

String text = "こんにちは";
//convert utf8 text to a byte array
byte[] array = text.getBytes("UTF-8");
//convert the byte array back to a string as UTF-8
String s = new String(array, Charset.forName("UTF-8"));
System.out.println(s);
//forcing strings encoded as UTF-8 as an incorrect encoding like
//say ISO-8859-1 causes strange and undefined behavior
String sISO = new String(array, Charset.forName("ISO-8859-1"));
System.out.println(sISO);

Imprime su cadena interpretada como UTF-8, y luego nuevamente como ISO-8859-1:

こんにちは
ããã«ã¡ã¯

la raíz de esta pregunta es ¿cómo decodificar bytes en cadenas?

esto se puede hacer con JAVA NIO CharSet:

public final CharBuffer decode(ByteBuffer bb)

FileChannel channel = FileChannel.open(
  Paths.get("files/text-latin1.txt", StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);

CharSet latin1 = StandardCharsets.ISO_8859_1;
CharBuffer latin1Buffer = latin1.decode(buffer);

String result = new String(latin1Buffer.array());

• Primero creamos un canal y lo leemos en un búfer
• Luego, el método de decodificación decodifica un búfer Latin1 en un búfer char
• Luego podemos poner el resultado, por ejemplo, en una cadena

private String convertFrom(String lines, String from, String to) {
    ByteBuffer bb = ByteBuffer.wrap(lines.getBytes());
    CharBuffer cb = Charset.forName(to).decode(bb);
    return new String(Charset.forName(from).encode(cb).array());
};
public Doit(){
    String concatenatedLines = convertFrom(concatenatedLines, "CP1252", "UTF-8");
};