data - long java example
¿Cómo puedo convertir Long to byte[] y volver a Java? (10)
¿Por qué necesitas el byte []? ¿por qué no solo escribirlo en el zócalo?
Supongo que te refieres a long en lugar de Long , este último necesita permitir valores nulos.
DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(socket.getOutputStream()));
dos.writeLong(longValue);
DataInputStream dis = new DataInputStream(
new BufferedInputStream(socket.getInputStream()));
long longValue = dis.readLong();
¿Cómo convierto un long a byte [] y viceversa en Java? Estoy intentando convertir un largo en un byte [] para que pueda enviar el byte [] a través de una conexión tcp. En el otro lado, quiero tomar ese byte [] y convertirlo nuevamente en un doble. Cualquier consejo sería apreciado.
Agregaré otra respuesta, que es la más rápida posible ׂ (sí, incluso más que la respuesta aceptada), PERO no funcionará para todos los casos. SIN EMBARGO, FUNCIONARÁ para cada escenario concebible:
Simplemente puede usar String como intermedio. Tenga en cuenta que esto le dará el resultado correcto aunque parezca que usar String podría arrojar los resultados incorrectos MIENTRAS SABE QUE ESTÁ TRABAJANDO CON CADENAS "NORMALES". Este es un método para aumentar la efectividad y simplificar el código que, a cambio, debe usar algunas suposiciones sobre las cadenas de datos en las que opera.
Uso de este método: si está trabajando con algunos caracteres ASCII como estos símbolos al principio de la tabla ASCII, las siguientes líneas pueden fallar, pero seamos sinceros, probablemente nunca las use de todos modos.
Pro de utilizar este método: recuerde que la mayoría de la gente suele trabajar con algunas cadenas normales sin ningún tipo de caracteres inusuales y luego el método es la manera más simple y rápida de hacerlo.
de Long a byte []:
byte[] arr = String.valueOf(longVar).getBytes();
de byte [] a largo:
long longVar = Long.valueOf(new String(byteArr)).longValue();
Probé el método ByteBuffer contra operaciones bit a bit sin formato, pero el último es significativamente más rápido.
public static byte[] longToBytes(long l) {
byte[] result = new byte[8];
for (int i = 7; i >= 0; i--) {
result[i] = (byte)(l & 0xFF);
l >>= 8;
}
return result;
}
public static long bytesToLong(byte[] b) {
long result = 0;
for (int i = 0; i < 8; i++) {
result <<= 8;
result |= (b[i] & 0xFF);
}
return result;
}
Puede usar la implementación en org.apache.hadoop.hbase.util.Bytes http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/util/Bytes.html
El código fuente está aquí:
Busque los métodos toLong y toBytes.
Creo que la licencia de software le permite tomar partes del código y usarlo, pero por favor verifique eso.
Puede usar los métodos de conversión de Byte de Google Guava .
Ejemplo:
byte[] bytes = Longs.toByteArray(12345L);
Si está buscando una versión desenrollada rápida, debería hacer el truco, suponiendo que una matriz de bytes llamada "b" con una longitud de 8:
long l = ((((long) b[7]) << 56) | (((long) b[6] & 0xff) << 48) | (((long) b[5] & 0xff) << 40)
| (((long) b[4] & 0xff) << 32) | (((long) b[3] & 0xff) << 24) | (((long) b[2] & 0xff) << 16)
| (((long) b[1] & 0xff) << 8) | (((long) b[0] & 0xff)));
Si ya está utilizando un OutputStream para escribir en el socket, entonces DataOutputStream podría ser una buena opción. Aquí hay un ejemplo:
// Assumes you are currently working with a SocketOutputStream.
SocketOutputStream outputStream = ...
long longValue = ...
DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
dataOutputStream.writeLong(longValue);
dataOutputStream.flush();
Hay métodos similares para short , int , float , etc. Luego puede usar DataInputStream en el lado de recepción.
Simplemente escriba el largo en un DataOutputStream con un ByteArrayOutputStream subyacente. Desde ByteArrayOutputStream puede obtener la matriz de bytes a través de toByteArray() :
class Main
{
public static byte[] long2byte(long l) throws IOException
{
ByteArrayOutputStream baos=new ByteArrayOutputStream(Long.SIZE/8);
DataOutputStream dos=new DataOutputStream(baos);
dos.writeLong(l);
byte[] result=baos.toByteArray();
dos.close();
return result;
}
public static long byte2long(byte[] b) throws IOException
{
ByteArrayInputStream baos=new ByteArrayInputStream(b);
DataInputStream dos=new DataInputStream(baos);
long result=dos.readLong();
dos.close();
return result;
}
public static void main (String[] args) throws java.lang.Exception
{
long l=123456L;
byte[] b=long2byte(l);
System.out.println(l+": "+byte2long(b));
}
}
Funciona para otros primitivos en consecuencia.
Sugerencia: para TCP no necesita el byte [] manualmente. Socket un socket Socket y sus streams
OutputStream os=socket.getOutputStream();
DataOutputStream dos=new DataOutputStream(os);
dos.writeLong(l);
//etc ..
en lugar.
public static long bytesToLong(byte[] bytes) {
if (bytes.length > 8) {
throw new IllegalMethodParameterException("byte should not be more than 8 bytes");
}
long r = 0;
for (int i = 0; i < bytes.length; i++) {
r = r << 8;
r += bytes[i];
}
return r;
}
public static byte[] longToBytes(long l) {
ArrayList<Byte> bytes = new ArrayList<Byte>();
while (l != 0) {
bytes.add((byte) (l % (0xff + 1)));
l = l >> 8;
}
byte[] bytesp = new byte[bytes.size()];
for (int i = bytes.size() - 1, j = 0; i >= 0; i--, j++) {
bytesp[j] = bytes.get(i);
}
return bytesp;
}
public byte[] longToBytes(long x) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.putLong(x);
return buffer.array();
}
public long bytesToLong(byte[] bytes) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.put(bytes);
buffer.flip();//need flip
return buffer.getLong();
}
O envuelto en una clase para evitar crear repetidamente ByteBuffers:
public class ByteUtils {
private static ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
public static byte[] longToBytes(long x) {
buffer.putLong(0, x);
return buffer.array();
}
public static long bytesToLong(byte[] bytes) {
buffer.put(bytes, 0, bytes.length);
buffer.flip();//need flip
return buffer.getLong();
}
}
Como esto se está volviendo tan popular, solo quiero mencionar que creo que es mejor usar una biblioteca como Guava en la gran mayoría de los casos. Y si tiene alguna oposición extraña a las bibliotecas, probablemente debería considerar esta respuesta primero para las soluciones nativas de Java. Creo que lo principal que mi respuesta realmente tiene es que usted no tiene que preocuparse por la endianidad del sistema usted mismo.