كيفية تحويل int [] إلى البايت [

Question

لدي مجموعة من الأعداد الصحيحة التي تمثل صورة RGB وترغب في تحويلها إلى صفيف بايت وحفظها في ملف.

ما هي أفضل طريقة لتحويل مجموعة من الأعداد الصحيحة إلى مجموعة بايت في جاوة؟

Answer 1

كما براين يقول، تحتاج إلى العمل كيف ما نوع التحويل الذي تحتاجه.

هل ترغب في حفظه كملف صورة "طبيعي" (JPG، PNG، إلخ)؟

إذا كان الأمر كذلك، فيجب عليك استخدام جافا صورة I / O API.

إذا كنت ترغب في حفظه بتنسيق "RAW"، يجب تحديد الترتيب الذي يكتب فيه البايت، ثم استخدم IntBuffer و nio.

كمثال على استخدام مزيج 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]);
        }
    }
}

Answer 2

ربما استخدم هذه الطريقة

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();
}  

Answer 3

تحتاج إلى تحديد كيفية تحويل عدد صحيح 1 إلى مجموعة من البايتات أولا.

على الأرجح (؟) 1 عدد صحيح إلى 4 بايت، واستخدام التحول (>> أو <<) المشغلون للحصول على كل بايت خارج (مشاهدة تلك البايت النظام!). انسخ إلى صفيف بايت 4 أضعاف طول صفيف عدد صحيح.

Answer 4

إذا كانت نيتك هي الحفظ في ملف، فربما ترغب في الحفظ مباشرة في ملف باستخدام FileOutPtStream.WRite:

    OutputStream os = new FileOutputStream("aa");
    int[] rgb = { 0xff, 0xff, 0xff };
    for (int c : rgb) {
        os.write(c);
    }
    os.close();

منذ ذلك:

يكتب البايت المحدد إلى هذا المخرجات. العقد العام للكتابة هو أن البايت واحد مكتوب إلى دفق الإخراج. البايت الذي يجب كتابته هو الجزء الثماني من الحجة المنخفضة من الحجة ب. يتم تجاهل البتات العالية من B. من B.

Answer 5

قمت بإنشاء هذا الرمز وهو يعمل بشكل جيد:

    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;
    }

Answer 6

أود استخدام "dataoutputstream" مع "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));
    }
}

مطبوعات:

[-1000000, 24000, -1, 40]
[-1, -16, -67, -64, 0, 0, 93, -64, -1, -1, -1, -1, 0, 0, 0, 40]
[-1000000, 24000, -1, 40]