एक स्ट्रिंग सरणी को बाइट सरणी में कैसे परिवर्तित करें? (जावा)

Question

मेरे पास एक आयामी स्ट्रिंग सरणी है जिसे मैं एक आयामी बाइट सरणी में परिवर्तित करना चाहता हूं। मैं यह कैसे करु? क्या इसे बाइटबफर की आवश्यकता है? मैं यह कैसे कर सकता हूँ? (तार किसी भी लम्बाई हो सकता है, बस इस तरह के एक अधिनियम करने के बारे में जाने के लिए कैसे जानना चाहते हैं। और बाद में आप इसे एक बाइट सरणी में तब्दील कैसे मैं इसे वापस परिवर्तित कर सकते हैं एक स्ट्रिंग सरणी में?

-Dan

Answer 1

सरणी को सरणी आप मैन्युअल दोनों पक्षों में पार्स करने के साथ परिवर्तित करना चाहिए, लेकिन तुम सिर्फ एक स्ट्रिंग आप कर सकते हैं String.getBytes() और new String(byte[] data) अगर;। इस

की तरह

public static void main(String[] args) { 
    String[] strings = new String[]{"first", "second"}; 
    System.out.println(Arrays.toString(strings)); 
    byte[][] byteStrings = convertToBytes(strings); 
    strings = convertToStrings(byteStrings); 
    System.out.println(Arrays.toString(strings)); 

} 

private static String[] convertToStrings(byte[][] byteStrings) { 
    String[] data = new String[byteStrings.length]; 
    for (int i = 0; i < byteStrings.length; i++) { 
     data[i] = new String(byteStrings[i], Charset.defaultCharset()); 

    } 
    return data; 
} 


private static byte[][] convertToBytes(String[] strings) { 
    byte[][] data = new byte[strings.length][]; 
    for (int i = 0; i < strings.length; i++) { 
     String string = strings[i]; 
     data[i] = string.getBytes(Charset.defaultCharset()); // you can chose charset 
    } 
    return data; 
} 

---

के लिए एक बाइट [] से स्ट्रिंग [] आप के लिए है:

प्रत्येक स्ट्रिंग से bytearray concat बाइट सरणियों को
• ते ही सीमांकक द्वारा bytearray विभाजन से कुछ delimeter
• का उपयोग कर और ऊपर वर्णित Iके रूप में स्ट्रिंग बनाएं।

Answer 2

?

String.getBytes() है आप जो खोज रहे हैं

Answer 3

आप प्रत्येक स्ट्रिंग के लिए पुनरावृत्त कर सकते हैं और अंतिम बाइट सरणी में शामिल रह सकते हैं।

String example = "This is an example"; 
//Convert String to byte[] using .getBytes() function 
byte[] bytes = example.getBytes(); 
//Convert byte[] to String using new String(byte[])  
String s = new String(bytes); 

Answer 4

आप कहते हैं कि क्या आप बाइट्स के साथ (से अलग करने के लिए उन्हें एक String[] बाद में वापस परिवर्तित) करना चाहते हैं, लेकिन आप केवल डेटा की एक अपारदर्शी बैग (के रूप में उन्हें इलाज कर सकते हैं यह सोचते हैं तो आप को बचा सकता है उन्हें एक फाइल में भेज दें या उन्हें नेटवर्क या व्हाट्नॉट पर भेजें, लेकिन आपको किसी भी तरह से जांच या संशोधित करने की आवश्यकता नहीं है), मुझे लगता है कि आपकी सबसे अच्छी शर्त धारावाहिकता का उपयोग करना है। अपने स्ट्रिंग सरणी को क्रमानुसार के लिए, आप की तरह कुछ लिखते थे:

final String[] stringArray = { "foo", "bar", "baz" }; 

final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); 
final ObjectOutputStream objectOutputStream = 
    new ObjectOutputStream(byteArrayOutputStream); 
objectOutputStream.writeObject(stringArray); 
objectOutputStream.flush(); 
objectOutputStream.close(); 

final byte[] byteArray = byteArrayOutputStream.toByteArray(); 

और यह बाद में ठीक करने के लिए, आप रिवर्स लिखना चाहते हैं:

final ByteArrayInputStream byteArrayInputStream = 
    new ByteArrayInputStream(byteArray); 
final ObjectInputStream objectInputStream = 
    new ObjectInputStream(byteArrayInputStream); 

final String[] stringArray2 = (String[]) objectInputStream.readObject(); 

objectInputStream.close(); 

Answer 5

मैं एक क्रमबद्धता समस्या के रूप में इस का इलाज और सिर्फ होगा

import java.nio.ByteBuffer; 
import java.util.ArrayList; 

public class Serialization { 
    public static byte[] serialize(String[] strs) { 
     ArrayList<Byte> byteList = new ArrayList<Byte>(); 
     for (String str: strs) { 
      int len = str.getBytes().length; 
      ByteBuffer bb = ByteBuffer.allocate(4); 
      bb.putInt(len); 
      byte[] lenArray = bb.array(); 
      for (byte b: lenArray) { 
       byteList.add(b); 
      } 
      byte[] strArray = str.getBytes(); 
      for (byte b: strArray) { 
       byteList.add(b); 
      } 
     } 
     byte[] result = new byte[byteList.size()]; 
     for (int i=0; i<byteList.size(); i++) { 
      result[i] = byteList.get(i); 
     } 
     return result; 
    } 

    public static String[] unserialize(byte[] bytes) { 
     ArrayList<String> strList = new ArrayList<String>(); 
     for (int i=0; i< bytes.length;) { 
      byte[] lenArray = new byte[4]; 
      for (int j=i; j<i+4; j++) { 
       lenArray[j-i] = bytes[j]; 
      } 
      ByteBuffer wrapped = ByteBuffer.wrap(lenArray); 
      int len = wrapped.getInt(); 
      byte[] strArray = new byte[len]; 
      for (int k=i+4; k<i+4+len; k++) { 
       strArray[k-i-4] = bytes[k]; 
      } 
      strList.add(new String(strArray)); 
      i += 4+len; 
     } 
     return strList.toArray(new String[strList.size()]); 
    } 

    public static void main(String[] args) { 
     String[] input = {"This is","a serialization problem;","string concatenation will do as well","in some cases."}; 
     byte[] byteArray = serialize(input); 
     String[] output = unserialize(byteArray); 
     for (String str: output) { 
      System.out.println(str); 
     } 
    } 
} 

विचार यह है कि जिसके परिणामस्वरूप बाइट सरणी में हम (पहली स्ट्रिंग की लंबाई जो हमेशा 4 बाइट है अगर हम प्रयोग की दुकान है: यह के रूप में (पूर्ण और काम कर रहे जावा कोड) इस प्रकार से लागू किया int टाइप करें), उसके बाद पहली स्ट्रिंग के बाइट्स (जिनकी लंबाई पिछले 4 बाइट्स से बाद में पढ़ी जा सकती है), उसके बाद दूसरी स्ट्रिंग की लंबाई और दूसरी स्ट्रिंग के बाइट्स के बाद, और इसी तरह। इस प्रकार, स्ट्रिंग सरणी को परिणामी बाइट सरणी से आसानी से पुनर्प्राप्त किया जा सकता है, जैसा ऊपर दिए गए कोड द्वारा प्रदर्शित किया गया है। और यह क्रमिकरण दृष्टिकोण किसी भी स्थिति को संभाल सकता है।

और यदि हम इनपुट स्ट्रिंग सरणी के लिए एक धारणा बनाने के कोड बहुत सरल हो सकता है:

public class Concatenation { 
    public static byte[] concatenate(String[] strs) { 
     StringBuilder sb = new StringBuilder(); 
     for (int i=0; i<strs.length; i++) { 
      sb.append(strs[i]); 
      if (i != strs.length-1) { 
       sb.append("*.*"); //concatenate by this splitter 
      } 
     } 
     return sb.toString().getBytes(); 
    } 

    public static String[] split(byte[] bytes) { 
     String entire = new String(bytes); 
     return entire.split("\\*\\.\\*"); 
    } 

    public static void main(String[] args) { 
     String[] input = {"This is","a serialization problem;","string concatenation will do as well","in some cases."}; 
     byte[] byteArray = concatenate(input); 
     String[] output = split(byteArray); 
     for (String str: output) { 
      System.out.println(str); 
     } 
    } 
} 

धारणा है कि *.* इनपुट सरणी से कोई भी स्ट्रिंग में मौजूद नहीं है है। दूसरे शब्दों में, यदि आप पहले से जानते हैं तो इनपुट सरणी के किसी भी स्ट्रिंग में प्रतीकों का कुछ विशेष अनुक्रम दिखाई नहीं देगा, तो आप उस अनुक्रम को स्प्लिटर के रूप में उपयोग कर सकते हैं।

Answer 6

आप देख सकते हैं इस

package javaapplication2; 

import java.util.Arrays; 


/** 
* 
* @author Ali 
*/ 
public class JavaApplication2 { 


public static byte[] to_byte(String[] strs) { 
     byte[] bytes=new byte[strs.length]; 
     for (int i=0; i<strs.length; i++) { 
      bytes[i]=Byte.parseByte(strs[i]); 
     } 
     return bytes; 
    } 


    public static void main(String[] args) { 
     String[] input = {"1","2","3"};  //original data 
     byte[] byteArray = to_byte(input);//data to byte array 
     String[] recovered=Arrays.toString(byteArray).split(",");// recovered data 

    }  
} 

Answer 7

पहले स्ट्रिंग की घोषणा की तरह मैं यहाँ str="Suresh"
दूसरा उपयोग getBytes() घोषित बाइट में परिवर्तित करना
getBytes बाइट की सरणी देता है।

String str="Suresh"; 
byte[] s=str.getBytes();