如何將字符串數組轉換爲字節數組？ （java）

Question

我有一個一維字符串數組，我想轉換成一維字節數組。我該怎麼做呢？這是否需要ByteBuffer？我怎樣才能做到這一點？ （該字符串可以是任意長度，只是想知道如何去這樣做，這種行爲，而且可以將其轉換爲字節數組後，我怎麼可能把它轉換回一個String數組？

-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字節數組使用一些定界符
• 從字節組分割由TE相同分隔符和創建字符串，如上所述我 。

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[]之後）什麼，但假設你可以把它們作爲數據的不透明的布袋（這樣還可以節省他們到一個文件或發送他們通過網絡或whatnot，但你不需要檢查或修改他們），我認爲你最好的選擇是使用序列化。序列化的字符串數組，你會寫是這樣的：

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

我會將此視爲一個序列化的問題，只是實現它如下（完全的和工作的Java代碼）：

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