虽然base64编码是安全的，而且有人可能会说“答案是正确的”，但我来到这里是为了寻找一种将java字节数组转换成java字符串的方法。也就是说，字节数组的每个成员在其对应的字符串中保持不变，编码/传输不需要额外的空间。
这个描述8位透明编码的答案对我很有帮助。我曾经 ISO-8859-1 在TB的二进制数据上成功地来回转换（二进制<->字符串），而不需要base64编码所需的膨胀空间，因此对于我的用例ymmv来说是安全的。
这也有助于解释何时/是否应该进行实验。

这对我来说很好：

String cd="Holding some value";

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

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

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

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

从中读取字节 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();
        }

    }
}

输出为：
萨哈尔是个好孩子

字符串是字符（16位无符号）的集合。所以如果你要把负数转换成一个字符串，它们会在翻译中丢失。

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

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

这是工作代码。

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

可以使用简单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);
}

尝试在两种转换中指定8位字符集。例如iso-8859-1。

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

我确实注意到了一些答案中没有的东西。您可以将字节数组中的每个字节转换为字符，然后将它们放入char数组中。那么字符串就是

new String(cbuf)

其中cbuf是char数组。若要转换回，请通过将每个字符转换为字节的字符串进行循环，以放入一个字节数组，这个字节数组将与第一个字节数组相同。

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

}

尽管

new String(bytes, "UTF-8")

正确吗？它抛出一个 UnsupportedEncodingException 强制您处理选中的异常。您可以使用Java1.6以来的另一个构造函数将字节数组转换为 String :

new String(bytes, StandardCharsets.UTF_8)

这个不会引发任何异常。
转换回也应该用 StandardCharsets.UTF_8 :

"test".getBytes(StandardCharsets.UTF_8)

同样，您可以避免处理选中的异常。

之间的“适当转换” byte[] 以及 String 是显式声明要使用的编码。如果你从一个 byte[] 而且它实际上不包含文本数据，没有“适当的转换”。 String s代表文本， byte[] 对于二进制数据，唯一真正明智的做法是避免在它们之间进行转换，除非您必须这样做。
如果你真的要用 String 要保存二进制数据，最安全的方法是使用base64编码。

下面是一些将字节数组转换为字符串的方法。我已经测试过了，效果很好。

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

}

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

bytes != encode(decode(bytes))

在某些情况下。utf-8就是这种字符集的一个例子。具体来说，某些字节序列在utf-8中不是有效编码。如果utf-8解码器遇到这些序列中的一个，那么它可能会丢弃有问题的字节，或者将它们解码为“没有这样的字符”的unicode码点。当然，当您尝试将字符编码为字节时，结果会有所不同。
解决方案是：
明确你使用的字符编码；i、 e.使用字符串构造函数 String.toByteArray 具有显式字符集的方法。
对字节数据使用正确的字符集。。。或者一个（例如“拉丁-1”，其中所有字节序列都Map到有效的unicode字符。
如果您的字节是（真的）二进制数据，并且希望能够通过“基于文本”的通道传输/接收它们，请使用base64编码之类的方法。。。它就是为此而设计的。

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