int [] से बाइट को परिवर्तित करने के लिए []

Question

मेरे पास पूर्णांक की एक सरणी है जो एक आरजीबी छवि का प्रतिनिधित्व करती है और इसे एक बाइट सरणी में परिवर्तित करना और इसे फ़ाइल में सहेजना चाहती है।

जावा में बाइट्स की सरणी में पूर्णांक की सरणी को परिवर्तित करने का सबसे अच्छा तरीका क्या है?

Answer 1

Brian के रूप में कहते हैं का उपयोग करें, आप बाहर काम करने के लिए कैसे रूपांतरण किस तरह आप की जरूरत की जरूरत है।

क्या आप इसे "सामान्य" छवि फ़ाइल (jpg, png आदि) के रूप में सहेजना चाहते हैं?

यदि ऐसा है, तो आपको शायद Java Image I/O API का उपयोग करना चाहिए।

यदि आप इसे "कच्चे" प्रारूप में सहेजना चाहते हैं, तो बाइट्स लिखने के क्रम को निर्दिष्ट किया जाना चाहिए, और फिर IntBuffer और एनआईओ का उपयोग करें।

एक 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

आपको यह तय करने की आवश्यकता है कि आप 1 पूर्णांक को बाइट्स के सेट में कैसे परिवर्तित करते हैं।

अधिकांश शायद (?) 1 से 4 बाइट्स पूर्णांक, और पाली (>> या <<) ऑपरेटर का उपयोग प्रत्येक (कि बाइट आदेश घड़ी!) बाहर बाइट प्राप्त करने के लिए। एक बाइट सरणी को पूर्णांक सरणी की लंबाई 4 गुना प्रतिलिपि बनाएँ।

Answer 3

हो सकता है कि इस विधि

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 4

अपने इरादे FileOutputStream.write दायर करने के लिए आप शायद का उपयोग कर एक फाइल में सीधे सहेजना चाहते को बचाने के लिए है अगर:

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

इसके बाद से:

इस आउटपुट स्ट्रीम में निर्दिष्ट बाइट लिखता है। लिखने के लिए सामान्य अनुबंध यह है कि एक बाइट आउटपुट स्ट्रीम में लिखा जाता है। बाइट लिखा जाना है तर्क के आठ कम ऑर्डर बिट्स बी। बी के 24 उच्च आदेश बिट्स को नजरअंदाज कर दिया जाता है।

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

मैं 'ByteArrayOutputStream' के साथ 'DataOutputStream' का प्रयोग करेंगे।

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]