如何将字节数组转换为字符串，反之亦然？

我必须在Android中将字节数组转换为字符串，但是我的字节数组包含负值。

如果我再次将该字符串转换为字节数组，则得到的值与原始字节数组值不同。

我该怎么做才能正确转换？我用于执行转换的代码如下：

// Code to convert byte arr to str:
byte[] by_original = {0,1,-2,3,-4,-5,6};
String str1 = new String(by_original);
System.out.println("str1 >> "+str1);

// Code to convert str to byte arr:
byte[] by_new = str1.getBytes();
for(int i=0;i<by_new.length;i++) 
System.out.println("by1["+i+"] >> "+str1);

我陷入了这个问题。

您的字节数组必须具有某种编码。如果值为负，则编码不能为ASCII。一旦弄清楚了，就可以使用以下方法将一组字节转换为字符串：

byte[] bytes = {...}
String str = new String(bytes, "UTF-8"); // for UTF-8 encoding

您可以使用许多编码，请查看Sun javadocs中的Charset类。

byte[]和之间的“正确转换” String用于明确说明您要使用的编码。如果以a开头byte[]且实际上不包含文本数据，则没有 “正确转换”。Strings用于文本，byte[]用于二进制数据，唯一真正明智的做法是避免在它们之间进行转换，除非绝对必要。

如果确实必须使用A String来保存二进制数据，那么最安全的方法是使用Base64编码。

根本问题是（我认为）您无意中使用了以下字符集：

 bytes != encode(decode(bytes))

在某些情况下。UTF-8是此类字符集的示例。具体来说，某些字节序列在UTF-8中不是有效的编码。如果UTF-8解码器遇到这些序列之一，则有可能丢弃有问题的字节或将它们解码为“无此类字符”的Unicode代码点。自然，当您随后尝试将字符编码为字节时，结果将有所不同。

解决方案是：

1. 明确说明您正在使用的字符编码；即使用字符串构造函数和String.toByteArray具有显式字符集方法。
2. 为您的字节数据使用正确的字符集...或替代一种（例如“ Latin-1”，其中所有字节序列都映射到有效的Unicode字符）。
3. 如果您的字节是（真的）二进制数据，并且您希望能够通过“基于文本”的通道发送/接收它们，请使用为此目的而设计的诸如Base64编码之类的东西。

我们只需要String使用数组构建一个新数组：http : //www.mkyong.com/java/how-do-convert-byte-array-to-string-in-java/

String s = new String(bytes);

根据您使用的字符集，结果字符串的字节会有所不同。当您调用String＃时，新的String（bytes）和新的String（bytes，Charset.forName（“ utf-8”））和新的String（bytes，Charset.forName（“ utf-16”））都将具有不同的字节数组。 getBytes（）（取决于默认字符集）

使用new String(byOriginal)并转换回byte[]using getBytes()不能保证两个byte[]值相等。这是由于调用StringCoding.encode(..)将编码String到Charset.defaultCharset()。在此编码过程中，编码器可能会选择替换未知字符并进行其他更改。因此，using String.getBytes()可能不会返回您最初传递给构造函数的相等数组。

问题出在哪里：正如已经有人指出的那样： 如果您以byte []开头并且实际上不包含文本数据，则没有“正确转换”。字符串用于文本，byte []用于二进制数据，唯一真正明智的做法是避免在它们之间进行转换，除非绝对必要。

当我尝试从pdf文件创建byte []，然后将其转换为String，然后将String作为输入并转换回文件时，我正在观察此问题。

因此，请确保您的编码和解码逻辑与我相同。我将byte []显式编码为Base64并将其解码以再次创建文件。

用例： 由于某些限制，我试图发送byte[]，request(POST)过程如下：

PDF文件>> Base64.encodeBase64（byte []）>>字符串>>发送请求（POST）>>接收字符串>> Base64.decodeBase64（byte []）>>创建二进制文件

试试这个，这对我有用。

File file = new File("filePath");

        byte[] byteArray = new byte[(int) file.length()];

        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            fileInputStream.read(byteArray);

            String byteArrayStr= new String(Base64.encodeBase64(byteArray));

            FileOutputStream fos = new FileOutputStream("newFilePath");
            fos.write(Base64.decodeBase64(byteArrayStr.getBytes()));
            fos.close();
        } 
        catch (FileNotFoundException e) {
            System.out.println("File Not Found.");
            e.printStackTrace();
        }
        catch (IOException e1) {
            System.out.println("Error Reading The File.");
            e1.printStackTrace();
        }

这对我来说很好：

String cd="Holding some value";

从字符串转换为字节[]：

byte[] cookie = new sun.misc.BASE64Decoder().decodeBuffer(cd);

从byte []转换为字符串：

cd = new sun.misc.BASE64Encoder().encode(cookie);

private static String toHexadecimal(byte[] digest){
        String hash = "";
    for(byte aux : digest) {
        int b = aux & 0xff;
        if (Integer.toHexString(b).length() == 1) hash += "0";
        hash += Integer.toHexString(b);
    }
    return hash;
}

我确实注意到了所有答案中都没有的内容。您可以将字节数组中的每个字节转换为字符，然后将其放入char数组中。然后字符串是

new String(cbuf)

public class StringByteArrTest {

    public static void main(String[] args) {
        // put whatever byte array here
        byte[] arr = new byte[] {-12, -100, -49, 100, -63, 0, -90};
        for (byte b: arr) System.out.println(b);
        // put data into this char array
        char[] cbuf = new char[arr.length];
        for (int i = 0; i < arr.length; i++) {
            cbuf[i] = (char) arr[i];
        }
        // this is the string
        String s = new String(cbuf);
        System.out.println(s);

        // converting back
        byte[] out = new byte[s.length()];
        for (int i = 0; i < s.length(); i++) {
            out[i] = (byte) s.charAt(i);
        }
        for (byte b: out) System.out.println(b);
    }

}

javax.xml.bind.DatatypeConverter 应该这样做：

byte [] b = javax.xml.bind.DatatypeConverter.parseHexBinary("E62DB");
String s = javax.xml.bind.DatatypeConverter.printHexBinary(b);

这里有一些将字节数组转换为字符串的方法。我已经测试过它们运作良好。

public String getStringFromByteArray(byte[] settingsData) {

    ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(settingsData);
    Reader reader = new BufferedReader(new InputStreamReader(byteArrayInputStream));
    StringBuilder sb = new StringBuilder();
    int byteChar;

    try {
        while((byteChar = reader.read()) != -1) {
            sb.append((char) byteChar);
        }
    }
    catch(IOException e) {
        e.printStackTrace();
    }

    return sb.toString();

}

public String getStringFromByteArray(byte[] settingsData) {

    StringBuilder sb = new StringBuilder();
    for(byte willBeChar: settingsData) {
        sb.append((char) willBeChar);
    }

    return sb.toString();

}

即使

new String(bytes, "UTF-8")

是正确的，它抛出一个UnsupportedEncodingException，迫使您处理一个已检查的异常。从Java 1.6开始，您可以使用另一个构造函数来将字节数组转换为String：

new String(bytes, StandardCharsets.UTF_8)

这一点不会引发任何异常。

向后转换也应使用StandardCharsets.UTF_8：

"test".getBytes(StandardCharsets.UTF_8)

同样，您避免必须处理受检查的异常。

我使用此方法成功将字节数组转换为字符串：

public static String byteArrayToString(byte[] data){
    String response = Arrays.toString(data);

    String[] byteValues = response.substring(1, response.length() - 1).split(",");
    byte[] bytes = new byte[byteValues.length];

    for (int i=0, len=bytes.length; i<len; i++) {
        bytes[i] = Byte.parseByte(byteValues[i].trim());
    }

    String str = new String(bytes);
    return str.toLowerCase();
}

虽然base64编码是安全的，并且可以说出“正确的答案”，但我来到这里是在寻找一种将Java字节数组原样转换为Java String的方法。也就是说，字节数组的每个成员在其String副本中均保持不变，而无需进行编码/传输的额外空间。

描述8位透明编码的答案对我很有帮助。我使用ISO-8859-1了数TB的二进制数据来成功地进行来回转换（二进制<->字符串），而没有base64编码所需的膨胀空间要求，因此对于我的用例-YMMV是安全的。

这也有助于解释何时/是否应该进行实验。

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;    

private static String base64Encode(byte[] bytes)
{
    return new BASE64Encoder().encode(bytes);
}

private static byte[] base64Decode(String s) throws IOException
{
    return new BASE64Decoder().decodeBuffer(s);
}

这里是工作代码。

            // Encode byte array into string . TemplateBuffer1 is my bytearry variable.

        String finger_buffer = Base64.encodeToString(templateBuffer1, Base64.DEFAULT);
        Log.d(TAG, "Captured biometric device->" + finger_buffer);


        // Decode String into Byte Array. decodedString is my bytearray[] 
        decodedString = Base64.decode(finger_buffer, Base64.DEFAULT);

尝试在两次转换中都指定一个8位字符集。例如ISO-8859-1。

从读出的字节String使用ByteArrayInputStream和包装它与BufferedReader它是焦炭流，而不是字节流中与字节数据转换成字符串。

package com.cs.sajal;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class TestCls {

    public static void main(String[] args) {

        String s=new String("Sajal is  a good boy");

        try
        {
        ByteArrayInputStream bis;
        bis=new ByteArrayInputStream(s.getBytes("UTF-8"));

        BufferedReader br=new BufferedReader(new InputStreamReader(bis));
        System.out.println(br.readLine());

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

    }
}

输出为：

沙加尔是个好男孩

您可以使用简单的for循环进行转换：

public void byteArrToString(){
   byte[] b = {'a','b','$'};
   String str = ""; 
   for(int i=0; i<b.length; i++){
       char c = (char) b[i];
       str+=c;
   }
   System.out.println(str);
}

InputStream is = new FileInputStream("/home/kalt/Desktop/SUDIS/READY/ds.bin");
byte[] bytes = IOUtils.toByteArray(is);

字符串是char的集合（16位无符号）。因此，如果您要将负数转换为字符串，则它们会在翻译中丢失。

public class byteString {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        String msg = "Hello";
        byte[] buff = new byte[1024];
        buff = msg.getBytes("UTF-8");
        System.out.println(buff);
        String m = new String(buff);
        System.out.println(m);


    }

}

使用Base64并解决您的问题。它太容易使用了。 http://iharder.sourceforge.net/current/java/base64/