Jak przekonwertować tablicę ciągów na tablicę bajtów? (java)

Question

Mam jednowymiarową tablicę ciągów, którą chcę przekonwertować na jednowymiarową tablicę bajtów. Jak mam to zrobic? Czy to wymaga ByteBuffer? Jak mogę to zrobić? (Łańcuchy mogą być dowolnej długości, po prostu chcą wiedzieć, jak się do tego zabrać takiego czynu. I po przekonwertowaniu go do tablicy bajtów jak mogę przekonwertować go z powrotem do tablicy ciągów?

-Dan

Answer 1

Array do macierzy należy przekonwertować ręcznie z parsowania do obu stron, ale jeśli masz tylko String co można String.getBytes() i new String(byte[] data);. jak ten

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

---

na jeden bajt [] z string [] trzeba:

• do tablicaBitowa tablic concat bajtowych z każdego łańcucha za pomocą niektórych separatorem
• z tablicaBitowa rozłamu przez te samą separatora i utwórz ciąg jako I opisany powyżej.

Answer 2

?

String.getBytes() jest to, czego szukasz

Answer 3

Można iterować dla każdego ciągu i dołączać do ostatniej tablicy bajtów.

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

Nie mów, co chcesz zrobić z bajtów (oprócz konwertować je z powrotem do String[] później), ale przy założeniu, że można po prostu traktować je jako nieprzezroczystej torbie danych (dzięki czemu można zaoszczędzić je do pliku lub wyślij przez sieć lub coś innego, ale nie musisz ich w żaden sposób analizować ani modyfikować), myślę, że najlepiej jest użyć serializacji. Aby szeregować swoje string-tablicę, by napisać coś takiego:

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

i odzyskać je później, można by napisać odwrotnie:

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

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

objectInputStream.close(); 

Answer 5

Chciałbym traktować to jako problem serializacji i tylko realizowane w następujący sposób (kompletny i działa kod 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); 
     } 
    } 
} 

Chodzi o to, że w otrzymanej tablicy bajtów przechowujemy długość pierwszego ciągu (co jest zawsze 4 bajty jeśli używamy typ int), a następnie bajty pierwszego ciągu znaków (którego długość można odczytać później z poprzednich 4 bajtów), a następnie długość drugiego ciągu znaków i bajty drugiego łańcucha i tak dalej. W ten sposób tablica łańcuchów może zostać łatwo odzyskana z wynikowej tablicy bajtów, co zostało przedstawione w powyższym kodzie. I to podejście do serializacji może poradzić sobie z każdą sytuacją.

I kod może być znacznie prostsze, jeśli robimy założenie do tablicy ciąg wejściowy:

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

Założenie jest takie, że *.* nie istnieje w dowolny ciąg z tablicy wejściowej. Innymi słowy, jeśli wiesz wcześniej, że specjalna sekwencja symboli nie pojawi się w żadnym ciągu tablicy wejściowej, możesz użyć tej sekwencji jako splittera.

Answer 6

Można to sprawdzić

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

Pierwszy zadeklarować ciąg jak oświadczyłem tutaj str="Suresh"
Second korzystanie getBytes(), aby przekształcić go w bajtach
getBytes Zwraca tablicę bajtów.

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