Como converter int [] para byte []
-
23-08-2019 - |
Pergunta
Eu tenho uma matriz de inteiros que representam uma imagem de RGB e gostaria de convertê-lo em um array de bytes e salvá-lo em um arquivo.
Qual é a melhor maneira de converter um array de inteiros para a matriz de bytes em Java?
Solução
Como Brian diz, você precisa trabalhar para fora como que tipo de conversão que você precisa.
Você quer salvá-lo como um arquivo "normal" de imagem (jpg, png etc)?
Se assim for, você provavelmente deve usar a Java Imagem I / O API .
Se você quer salvá-lo em um formato "raw", a ordem em que para escrever os bytes deve ser especificado, e em seguida, usar um IntBuffer
e NIO.
Como um exemplo da utilização de uma combinação ByteBuffer / IntBuffer:
import java.nio.*;
import java.net.*;
class Test
{
public static void main(String [] args)
throws Exception // Just for simplicity!
{
int[] data = { 100, 200, 300, 400 };
ByteBuffer byteBuffer = ByteBuffer.allocate(data.length * 4);
IntBuffer intBuffer = byteBuffer.asIntBuffer();
intBuffer.put(data);
byte[] array = byteBuffer.array();
for (int i=0; i < array.length; i++)
{
System.out.println(i + ": " + array[i]);
}
}
}
Outras dicas
Talvez usar este método
byte[] integersToBytes(int[] values)
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
for(int i=0; i < values.length; ++i)
{
dos.writeInt(values[i]);
}
return baos.toByteArray();
}
Você precisa decidir como você converter um inteiro para um conjunto de bytes em primeiro lugar.
Muito provavelmente (?) 1 inteiro para 4 bytes, e usar o shift (>>
ou <<
) operadores para obter cada byte out (relógio que ordenação de bytes!). Copiar a uma matriz de bytes 4 vezes o comprimento da matriz de números inteiros.
Se a sua intenção é a de salvar em arquivo que você talvez queira salvar diretamente em um arquivo usando FileOutputStream.write:
OutputStream os = new FileOutputStream("aa");
int[] rgb = { 0xff, 0xff, 0xff };
for (int c : rgb) {
os.write(c);
}
os.close();
desde que:
Grava o byte especificado para este fluxo de saída. O contrato geral para gravação é que um byte é escrito para o fluxo de saída. O byte a ser escrito é os oito bits de baixa ordem do argumento b. Os 24 bits de alta ordem de b são ignorados.
Eu criei este código e que está funcionando muito bem:
int IntToByte(byte arrayDst[], int arrayOrg[], int maxOrg){
int i;
int idxDst;
int maxDst;
//
maxDst = maxOrg*4;
//
if (arrayDst==null)
return 0;
if (arrayOrg==null)
return 0;
if (arrayDst.length < maxDst)
return 0;
if (arrayOrg.length < maxOrg)
return 0;
//
idxDst = 0;
for (i=0; i<maxOrg; i++){
// Copia o int, byte a byte.
arrayDst[idxDst] = (byte)(arrayOrg[i]);
idxDst++;
arrayDst[idxDst] = (byte)(arrayOrg[i] >> 8);
idxDst++;
arrayDst[idxDst] = (byte)(arrayOrg[i] >> 16);
idxDst++;
arrayDst[idxDst] = (byte)(arrayOrg[i] >> 24);
idxDst++;
}
//
return idxDst;
}
int ByteToInt(int arrayDst[], byte arrayOrg[], int maxOrg){
int i;
int v;
int idxOrg;
int maxDst;
//
maxDst = maxOrg/4;
//
if (arrayDst==null)
return 0;
if (arrayOrg==null)
return 0;
if (arrayDst.length < maxDst)
return 0;
if (arrayOrg.length < maxOrg)
return 0;
//
idxOrg = 0;
for (i=0; i<maxDst; i++){
arrayDst[i] = 0;
//
v = 0x000000FF & arrayOrg[idxOrg];
arrayDst[i] = arrayDst[i] | v;
idxOrg++;
//
v = 0x000000FF & arrayOrg[idxOrg];
arrayDst[i] = arrayDst[i] | (v << 8);
idxOrg++;
//
v = 0x000000FF & arrayOrg[idxOrg];
arrayDst[i] = arrayDst[i] | (v << 16);
idxOrg++;
//
v = 0x000000FF & arrayOrg[idxOrg];
arrayDst[i] = arrayDst[i] | (v << 24);
idxOrg++;
}
//
return maxDst;
}
Gostaria de usar 'DataOutputStream' com 'ByteArrayOutputStream'.
public final class Converter {
private static final int BYTES_IN_INT = 4;
private Converter() {}
public static byte [] convert(int [] array) {
if (isEmpty(array)) {
return new byte[0];
}
return writeInts(array);
}
public static int [] convert(byte [] array) {
if (isEmpty(array)) {
return new int[0];
}
return readInts(array);
}
private static byte [] writeInts(int [] array) {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream(array.length * 4);
DataOutputStream dos = new DataOutputStream(bos);
for (int i = 0; i < array.length; i++) {
dos.writeInt(array[i]);
}
return bos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private static int [] readInts(byte [] array) {
try {
ByteArrayInputStream bis = new ByteArrayInputStream(array);
DataInputStream dataInputStream = new DataInputStream(bis);
int size = array.length / BYTES_IN_INT;
int[] res = new int[size];
for (int i = 0; i < size; i++) {
res[i] = dataInputStream.readInt();
}
return res;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
public class ConverterTest {
@Test
public void convert() {
final int [] array = {-1000000, 24000, -1, 40};
byte [] bytes = Converter.convert(array);
int [] array2 = Converter.convert(bytes);
assertTrue(ArrayUtils.equals(array, array2));
System.out.println(Arrays.toString(array));
System.out.println(Arrays.toString(bytes));
System.out.println(Arrays.toString(array2));
}
}
Prints:
[-1000000, 24000, -1, 40]
[-1, -16, -67, -64, 0, 0, 93, -64, -1, -1, -1, -1, 0, 0, 0, 40]
[-1000000, 24000, -1, 40]