Base64与byte[]相互转换

图片和base64编码字符串互相转换，图片和byte数组互相转换

图⽚和base64编码字符串互相转换，图⽚和byte数组互相转换图⽚和base64编码字符串互相转换import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.io.*;/*** @author lishupeng* @create 2017-05-06 下午 2:56**/public class Base64Test {public static void main(String[] args) {String strImg = GetImageStr();System.out.println(strImg);GenerateImage(strImg);}//图⽚转化成base64字符串public static String GetImageStr() {//将图⽚⽂件转化为字节数组字符串，并对其进⾏Base64编码处理String imgFile = "C:\\Users\\Administrator\\Desktop\\a\\1.png";//待处理的图⽚InputStream in = null;byte[] data = null;//读取图⽚字节数组try {in = new FileInputStream(imgFile);data = new byte[in.available()];in.read(data);in.close();} catch (IOException e) {e.printStackTrace();}//对字节数组Base64编码BASE64Encoder encoder = new BASE64Encoder();return encoder.encode(data);//返回Base64编码过的字节数组字符串}//base64字符串转化成图⽚public static boolean GenerateImage(String imgStr) { //对字节数组字符串进⾏Base64解码并⽣成图⽚if (imgStr == null) //图像数据为空return false;BASE64Decoder decoder = new BASE64Decoder();try {//Base64解码byte[] b = decoder.decodeBuffer(imgStr);for (int i = 0; i < b.length; ++i) {if (b[i] < 0) {//调整异常数据b[i] += 256;}}//⽣成jpeg图⽚String imgFilePath = "d://222.jpg";//新⽣成的图⽚OutputStream out = new FileOutputStream(imgFilePath);out.write(b);out.flush();out.close();return true;} catch (Exception e) {return false;}}图⽚和byte数组互相转换import javax.imageio.stream.FileImageInputStream;import javax.imageio.stream.FileImageOutputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileNotFoundException;import java.io.IOException;/*** @author lishupeng* @create 2017-05-06 下午 3:48**/public class Image2Byte {public static void main(String[] args){byte[] data = image2byte("C:\\Users\\Administrator\\Desktop\\a\\1.png");System.out.println(data.toString());byte2image(data,"d://222.jpg");}//图⽚到byte数组public static byte[] image2byte(String path) {byte[] data = null;FileImageInputStream input = null;try {input = new FileImageInputStream(new File(path));ByteArrayOutputStream output = new ByteArrayOutputStream();byte[] buf = new byte[1024];int numBytesRead = 0;while ((numBytesRead = input.read(buf)) != -1) {output.write(buf, 0, numBytesRead);}data = output.toByteArray();output.close();input.close();} catch (FileNotFoundException ex1) {ex1.printStackTrace();} catch (IOException ex1) {ex1.printStackTrace();}return data;}//byte数组到图⽚public static void byte2image(byte[] data, String path) {if (data.length < 3 || path.equals("")) return;try {FileImageOutputStream imageOutput = new FileImageOutputStream(new File(path)); imageOutput.write(data, 0, data.length);imageOutput.close();System.out.println("Make Picture success,Please find image in " + path);} catch (Exception ex) {System.out.println("Exception: " + ex);ex.printStackTrace();}}//byte数组到16进制字符串public String byte2string(byte[] data) {if (data == null || data.length <= 1) return "0x";if (data.length > 200000) return "0x";StringBuffer sb = new StringBuffer();int buf[] = new int[data.length];//byte数组转化成⼗进制for (int k = 0; k < data.length; k++) {buf[k] = data[k] < 0 ? (data[k] + 256) : (data[k]);}//⼗进制转化成⼗六进制for (int k = 0; k < buf.length; k++) {if (buf[k] < 16) sb.append("0" + Integer.toHexString(buf[k]));else sb.append(Integer.toHexString(buf[k]));}return "0x" + sb.toString().toUpperCase();}}。

python中bytes类型转换

Python中的bytes类型转换在Python中，bytes类型是一种不可变的数据类型，用于表示二进制数据。

bytes对象可以通过不同的方式进行创建和转换，以满足不同的需求。

本文将详细介绍Python中bytes类型的转换方法和使用案例。

1. bytes类型的基本概念在计算机中，所有的数据都是以二进制的形式存储和传输的。

bytes类型是Python 中用来表示二进制数据的一种数据类型。

它由一系列的字节组成，每个字节的取值范围是0-255。

bytes类型的对象是不可变的，即不能修改其值。

bytes类型有两种字面值表示方法： - 使用前缀b，后跟双引号或单引号，例如b'hello'或b"world"。

- 使用bytes()函数，传入一个字符串作为参数，例如bytes('hello', 'utf-8')。

2. bytes类型与字符串的相互转换在Python中，bytes类型与字符串之间的相互转换是常见的操作。

bytes类型可以通过编码（encode）方法转换为字符串，字符串可以通过解码（decode）方法转换为bytes类型。

2.1 bytes类型转换为字符串bytes类型可以通过decode()方法将其转换为字符串，需要指定字符编码方式。

常用的字符编码方式包括utf-8、gbk等。

b = b'hello's = b.decode('utf-8')print(s) # 输出：hello2.2 字符串转换为bytes类型字符串可以通过encode()方法将其转换为bytes类型，同样需要指定字符编码方式。

s = 'hello'b = s.encode('utf-8')print(b) # 输出：b'hello'3. bytes类型与整数的相互转换bytes类型可以与整数之间进行相互转换，其中整数表示字节的取值范围。

BASE64编码与解码

C＃实现Base64编码与解码Posted on 2008-01-17 16:43 小y阅读(2085) 评论(3)编辑收藏所属分类: [09] 串口通信&网络编程一、编码规则Base64编码的思想是是采用64个基本的ASCII码字符对数据进行重新编码。

它将需要编码的数据拆分成字节数组。

以3个字节为一组。

按顺序排列24 位数据，再把这24位数据分成4组，即每组6位。

再在每组的的最高位前补两个0凑足一个字节。

这样就把一个3字节为一组的数据重新编码成了4个字节。

当所要编码的数据的字节数不是3的整倍数，也就是说在分组时最后一组不够3个字节。

这时在最后一组填充1到2个0字节。

并在最后编码完成后在结尾添加1到2个“=”。

例：将对ABC进行BASE64编码：1、首先取ABC对应的ASCII码值。

A（65）B（66）C（67）；2、再取二进制值A（01000001）B（01000010）C（01000011）；3、然后把这三个字节的二进制码接起来（010000010100001001000011）；4、再以6位为单位分成4个数据块,并在最高位填充两个0后形成4个字节的编码后的值，（00010000）（00010100）（00001001）（00000011），其中蓝色部分为真实数据；5、再把这四个字节数据转化成10进制数得（16）（20）（9）（3）；6、最后根据BASE64给出的64个基本字符表，查出对应的ASCII码字符（Q）（U）（J）（D），这里的值实际就是数据在字符表中的索引。

注：BASE64字符表：ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/二、解码规则解码过程就是把4个字节再还原成3个字节再根据不同的数据形式把字节数组重新整理成数据。

三、C#中的实现编码类：///<summary>/// Base64编码类。

base64的编解码方法【最新】

Base64是一种很常用的编码方式，利用它可以将任何二进制的字符编码到可打印的64个字符之中，这样，不管是图片，中文文本等都可以编码成只有ASCII的纯文本。

至于为什么要进行这个转换呢，最初主要使用在EMail领域，早期的一些邮件网关只识别ASCII，如果发现邮件里有其他字符，就会将它们过滤掉，这样中文的邮件，有图片附件的邮件在这些网关上就会发生问题，于是将中文和图片都使用base64编码然后传输，接受后再解码就客服了这个问题了。

Base64除了可以使用在相似场合，还可以用作简单的加密等等。

下面介绍下Base64的方法：首先是Base64中可能出现的所有字符：0 A 17 R 34 i 51 z1 B 18 S 35 j 52 02 C 19 T 36 k 53 13 D 20 U 37 l 54 24 E 21 V 38 m 55 35 F 22 W 39 n 56 46 G 23 X 40 o 57 57 H 24 Y 41 p 58 68 I 25 Z 42 q 59 79 J 26 a 43 r 60 810 K 27 b 44 s 61 911 L 28 c 45 t 62 +12 M 29 d 46 u 63 /13 N 30 e 47 v14 O 31 f 48 w (pad) =15 P 32 g 49 x16 Q 33 h 50 y所有的字符就是'A'~'Z','a'~'z','0'~'9','+','/'共64个，以及末尾的填充字符'='编码的方法是：从输入缓冲中依次取出字符，第一个字符的，从最高位开始取出6个bit，这6个bit的值的范围在0~63，将这个值作为索引，对应上面的表格，找到相应的字符，这便是第一个Base64后的字符，然后将第一个字符的低2位与第二个字符的高4位组成6个bit, 同样查表得到第二个Base64字符，以此类推，从左向右没凑足6个bit就转换成一个Base64字符，由于输入缓冲中每3个字符包含24个bit，这24个bit正好可以转成4个Base64字符，所以没3个字符能组成一个转换循环，如果输入缓冲中字符的个数是3 的整数倍，那么结果就是4的整数倍，两者的长度是3:4的关系，但是如果输入字符不是3的整数倍呢？这就涉及到了末尾填充问题。

二进制totext

二进制totext将二进制数据转换为文本数据的过程通常称为二进制到文本的编码。

有几种常见的方法可以实现这个转换：1.Base64编码：•Base64编码是一种常见的二进制到文本的编码方法。

它将二进制数据转换为由64个字符组成的文本字符串。

•在Java中，可以使用Base64类进行编码和解码。

import java.util.Base64;public class BinaryToTextExample {public static void main(String[] args) {byte[] binaryData = { /* your binary data here */ };// 编码String encodedText =Base64.getEncoder().encodeToString(binaryData);System.out.println("Encoded Text: " + encodedText);// 解码byte[] decodedData =Base64.getDecoder().decode(encodedText);System.out.println("Decoded Data: " + newString(decodedData));}}2.ASCII编码：•ASCII编码是一种将字符转换为数字的标准方法，可以将二进制数据转换为ASCII字符。

•请注意，使用ASCII编码可能会导致数据膨胀，因为每个字节都被转换为两个字符。

public class BinaryToTextExample {public static void main(String[] args) {byte[] binaryData = { /* your binary data here */ };// 使用ASCII编码将二进制数据转换为文本String asciiText = new String(binaryData);System.out.println("ASCII Text: " + asciiText);}}选择编码方法取决于你的需求，Base64通常是更常见和高效的选择，特别是在处理二进制数据的网络传输和存储中。

java字符串和byte[]转换乱码问题

接口数据传输时经常把字符串转成byte[] , 经过Base64编码处理。

这里遇到一个问题，转换后中文乱码。

(开发环境正常，生产环境乱码)1.String localChartSet = System.getProperty("file.encoding");2.System.out.println("localChartSet>>>>"+localChartSet); //查看本地默认字符集3.4.String str ="aaaa中文的";5.byte[] gbkbt = str.getBytes("GB2312");6.byte[] utfbt = str.getBytes("utf-8");7.byte[] bt = str.getBytes();8.9.String gbkstr= new String(gbkbt, "GB2312"); //string 与byte[] 转换时字符集要保持一致10.String utfstr= new String(utfbt, "utf-8");11.str= new String(bt);12.13.System.out.println("gbkstr>>>>"+gbkstr);14.System.out.println("utfstr>>>>"+utfstr);15.System.out.println("str>>>>"+str);16.17.18.gbkstr= new String(gbkbt, "utf-8"); //转换时字符集要保持一致否则中文会出乱码19.utfstr= new String(utfbt, "GB2312");20.str= new String(bt, "GB2312");21.System.out.println("gbkstr>>>>"+gbkstr);22.System.out.println("utfstr>>>>"+utfstr);23.System.out.println("str>>>>"+str);24.new String(gbkbt, "GB2312"); //<span style="font-size:18px;">为了防止乱码，尽量采用这种方式 </span>。

base码转二进制

base码转二进制base码是一种将二进制数据转换为可显示字符的编码方式。

在计算机领域中，经常使用base64码来表示二进制数据。

本文将探讨base64码转换为二进制的过程，并介绍其应用和原理。

我们来了解一下base64码是如何将二进制数据转换为可显示字符的。

base64编码使用64个字符来表示二进制数据，包括大小写字母、数字和两个特殊字符。

每个字符的ASCII码值对应一个6位的二进制数，将这个6位的二进制数拼接起来，就可以得到base64码。

例如，我们有一个二进制数据010011100110100101101110，将其转换为base64码的过程如下：1. 将二进制数据按照6位一组进行分组，得到010011、100110、100101、101110。

2. 分组后的每个6位二进制数转换为十进制，得到19、38、37、46。

3. 根据base64编码表，将十进制数转换为对应的字符，得到T、m、l、u。

4. 将转换后的字符拼接起来，得到base64码Tmlu。

base64码的应用非常广泛。

在网络传输中，由于网络传输的数据只能是文本格式，无法直接传输二进制数据。

因此，需要将二进制数据转换为base64码后再进行传输。

在邮件中，附件也是通过将二进制文件转换为base64码进行传输的。

此外，在一些加密算法中，也会使用base64码进行数据的编码和解码。

base64码的转换原理可以通过以下步骤进行解释：1. 将输入的base64码按照每个字符进行解码，得到对应的6位二进制数。

2. 将这些6位二进制数拼接起来，得到二进制数据。

3. 将二进制数据按照8位一组进行分组，得到对应的字符。

虽然base64码可以将二进制数据转换为可显示字符，但它也有一定的缺点。

由于base64编码是将3个字节的数据转换为4个字符，因此会使得数据的长度增加约33%。

这就意味着在将大量二进制数据转换为base64码后，数据的大小会变得更大。

文件与base64相互转换

⽂件与base64相互转换package com.example.tool.controller;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;/*** Created by LQ on 2021/9/2.*/public class FileToBase64 {public static void main(String[] args){try {String base64Code = encodeBase64File("F:/aa.docx");System.out.println("base64:"+base64Code);decoderBase64File(base64Code, "F:/def.docx");toFile(base64Code, "F:\\def.txt");} catch (Exception e) {e.printStackTrace();}}/*** 将⽂件转成base64 字符串*/public static String encodeBase64File(String path) throws Exception {File file = new File(path);FileInputStream inputFile = new FileInputStream(file);// byte[] buffer = new byte[(int) file.length()];byte[] buffer = new byte[inputFile.available()]; // 如果在⽹络传输中存在弊端，数据可能分批次发送inputFile.read(buffer);inputFile.close();// 下⾯三种⽅式都可以将字节数组转为base64String base64 = new BASE64Encoder().encode(buffer);// 此种⽅法base64存在换⾏// String base64 = Base64Util.convertByteArrayToBase64String(buffer);// String base64 = Base64.encodeBase64String(buffer);return base64;}/*** 将base64字符解码保存⽂件*/public static void decoderBase64File(String base64Code, String targetPath) throws Exception {byte[] buffer = new BASE64Decoder().decodeBuffer(base64Code);FileOutputStream out = new FileOutputStream(targetPath);out.write(buffer);out.close();}/*** 将base64字符保存⽂本⽂件*/public static void toFile(String base64Code, String targetPath) throws Exception {byte[] buffer = base64Code.getBytes();FileOutputStream out = new FileOutputStream(targetPath);out.write(buffer);out.close();}}。

java中图片地址base64编码的相互转换

java中图⽚地址base64编码的相互转换public class Base64Url {/*** 将base64编码字符串转换为图⽚* @param imgStr: base64编码字符串* @param path: 图⽚路径-具体到⽂件* @return*/public static boolean getImage(String imgStr, String path){if (imgStr == null){return false;}BASE64Decoder decoder = new BASE64Decoder();try {// 解密byte[] b = decoder.decodeBuffer(imgStr);// 处理数据for (int i = 0; i < b.length; ++i) {if (b[i] < 0) {b[i] += 256;}}OutputStream out = new FileOutputStream(path);out.write(b);out.flush();out.close();return true;}catch (Exception e){return false;}}/*** @Description: 根据图⽚地址转换为base64编码字符串* @return* 需要注意的是，⼀般插件返回的base64编码的字符串都是有⼀个前缀的:"data:image/jpeg;base64," , 解码之前这个得去掉。

*/public static String getbase64Url(String imgFile) {InputStream inputStream = null;byte[] data = null;try {inputStream = new FileInputStream(imgFile);data = new byte[inputStream.available()];inputStream.read(data);inputStream.close();} catch (IOException e) {e.printStackTrace();}// 加密BASE64Encoder encoder = new BASE64Encoder();return encoder.encode(data);}public static void main(String[] args) {String strImg = getbase64Url("C:/Users/admin/Desktop/图⽚/桌⾯壁纸/2.jpg");System.out.println(strImg);boolean b = getImage(strImg, "C:/Users/admin/Desktop/图⽚/桌⾯壁纸/2.jpg");System.out.println("==========================================================");System.out.println(b);}}原⽂：。

Byte[]和BASE64之间的转换

Byte[]和BASE64之间的转换编码把byte[]中的元素当做⽆符号⼋位整数转换成只含有64个基本字符的字符串，这些基本字符是：l⼤写的A-Zl⼩写的a-zl数字0-9l'+' 和 '/'这64个字符构成BASE64的字符集。

‘=’，为填充字符，结尾处可以填充0-2个填充字符Base64是将原⽂按照每 3 个字节⼀组分开，这个 3 字节组中的每⼀组将被按照位分解成 4 个部分，每个部分 6 个位，在这 4 个部分的每个部分⾼位加上 2 个 0构成⼀个新的 4 字节组，新的字节组中，每个字节只有 6 位，能表⽰64个值。

在原⽂在转换为BASE64编码时，试是以3个字节为⼀组转换成4字节⼀组的BASE64编码。

如果原⽂不是三字节的倍数，可能多出⼀个字节和两个字节，分别会被转为2字节和3字节的BASE64编码，这时编码系统应该在形成的BASE64编码最后添加上填充符”=”，保证BASE64编码长度是4的倍数。

所以在BASE64编码后添加的填充符”=”可能为0-2个。

BASE64编码对照表如下：Value Encoding Value Encoding Value Encoding Value Encoding0A16Q32g48w1B17R33h49x2C18S34i50y3D19T35j51z4E20U36k5205F21V37l5316G22W38m5427H23X39n5538I24Y40o5649J25Z41p57510K26a42q58611L27b43r59712M28c44s60813N29d45t61914O30e46u62+15P31f47v63/Byte[]和BASE64之间的转换纯粹就是表现形式的⼀种转换，它们之间有直接的对应关系，不涉及到使⽤何种代码页的问题，BASE64表达的也是字节流。

实际应⽤中，dotnet提供的两个主要的BASE64⽅法Convert.ToBase64String 和 Convert.FromBase64String，并不是把Byte[]直接转成相应的BASE64的字节流，⽽是转换成unicode的等价字符串，就是base64的值对应的字符在unicode的等价字符。

byte[]与各种数据类型互相转换示例

byte[]与各种数据类型互相转换⽰例博客分类：在socket开发过程中，通常需要将⼀些具体的值（这些值可能是各种JAVA类型）转化为byte[]类型，为此我总结了如下这个⽰例，贴出来，以便经常翻看Java代码1. public class TestCase {2.3. /**4. * short到字节数组的转换.5. */6. public static byte[] shortToByte(short number) {7. int temp = number;8. byte[] b = new byte[2];9. for (int i = 0; i < b.length; i++) {10. b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位11. temp = temp >> 8;// 向右移8位12. }13. return b;14. }15.16. /**17. * 字节数组到short的转换.18. */19. public static short byteToShort(byte[] b) {20. short s = 0;21. short s0 = (short) (b[0] & 0xff);// 最低位22. short s1 = (short) (b[1] & 0xff);23. s1 <<= 8;24. s = (short) (s0 | s1);25. return s;26. }27.28.29. /**30. * int到字节数组的转换.31. */32. public static byte[] intToByte(int number) {33. int temp = number;34. byte[] b = new byte[4];35. for (int i = 0; i < b.length; i++) {36. b[i] = new Integer(temp & 0xff).byteValue();// 将最低位保存在最低位37. temp = temp >> 8;// 向右移8位38. }39. return b;40. }41.42. /**43. * 字节数组到int的转换.44. */45. public static int byteToInt(byte[] b) {46. int s = 0;47. int s0 = b[0] & 0xff;// 最低位48. int s1 = b[1] & 0xff;49. int s2 = b[2] & 0xff;50. int s3 = b[3] & 0xff;51. s3 <<= 24;52. s2 <<= 16;53. s1 <<= 8;54. s = s0 | s1 | s2 | s3;55. return s;56. }57.58.59. /**60. * long类型转成byte数组61. */62. public static byte[] longToByte(long number) {63. long temp = number;64. byte[] b = new byte[8];65. for (int i = 0; i < b.length; i++) {66. b[i] = new Long(temp & 0xff).byteValue();// 将最低位保存在最低位 temp = temp67. // >> 8;// 向右移8位68. }69. return b;70. }71.71.72. /**73. * 字节数组到long的转换.74. */75. public static long byteToLong(byte[] b) {76. long s = 0;77. long s0 = b[0] & 0xff;// 最低位78. long s1 = b[1] & 0xff;79. long s2 = b[2] & 0xff;80. long s3 = b[3] & 0xff;81. long s4 = b[4] & 0xff;// 最低位82. long s5 = b[5] & 0xff;83. long s6 = b[6] & 0xff;84. long s7 = b[7] & 0xff;85.86. // s0不变87. s1 <<= 8;88. s2 <<= 16;89. s3 <<= 24;90. s4 <<= 8 * 4;91. s5 <<= 8 * 5;92. s6 <<= 8 * 6;93. s7 <<= 8 * 7;94. s = s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7;95. return s;96. }97.98. /**99. * double到字节数组的转换.100. */101. public static byte[] doubleToByte(double num) { 102. byte[] b = new byte[8];103. long l = Double.doubleToLongBits(num); 104. for (int i = 0; i < 8; i++) {105. b[i] = new Long(l).byteValue();106. l = l >> 8;107. }108. return b;109. }110.111. /**112. * 字节数组到double的转换.113. */114. public static double getDouble(byte[] b) { 115. long m;116. m = b[0];117. m &= 0xff;118. m |= ((long) b[1] << 8);119. m &= 0xffff;120. m |= ((long) b[2] << 16);121. m &= 0xffffff;122. m |= ((long) b[3] << 24);123. m &= 0xffffffffl;124. m |= ((long) b[4] << 32);125. m &= 0xffffffffffl;126. m |= ((long) b[5] << 40);127. m &= 0xffffffffffffl;128. m |= ((long) b[6] << 48);129. m &= 0xffffffffffffffl;130. m |= ((long) b[7] << 56);131. return Double.longBitsToDouble(m);132. }133.134.135. /**136. * float到字节数组的转换.137. */138. public static void floatToByte(float x) {139. //先⽤ Float.floatToIntBits(f)转换成int140. }141.142. /**143. * 字节数组到float的转换.144. */145. public static float getFloat(byte[] b) {146. // 4 bytes147. int accum = 0;148. for ( int shiftBy = 0; shiftBy < 4; shiftBy++ ) { 149. accum |= (b[shiftBy] & 0xff) << shiftBy * 8; 150. }151. return Float.intBitsToFloat(accum);152. }153.154. /**155. * char到字节数组的转换.156. */157. public static byte[] charToByte(char c){158. byte[] b = new byte[2];159. b[0] = (byte) ((c & 0xFF00) >> 8);160. b[1] = (byte) (c & 0xFF);161. return b;161. return b;162. }163.164. /**165. * 字节数组到char的转换.166. */167. public static char byteToChar(byte[] b){168. char c = (char) (((b[0] & 0xFF) << 8) | (b[1] & 0xFF));169. return c;170. }171.172. /**173. * string到字节数组的转换.174. */175. public static byte[] stringToByte(String str) throws UnsupportedEncodingException{ 176. return str.getBytes("GBK");177. }178.179. /**180. * 字节数组到String的转换.181. */182. public static String bytesToString(byte[] str) {183. String keyword = null;184. try {185. keyword = new String(str,"GBK");186. } catch (UnsupportedEncodingException e) {187. e.printStackTrace();188. }189. return keyword;190. }191.192.193. /**194. * object到字节数组的转换195. */196. @Test197. public void testObject2ByteArray() throws IOException,198. ClassNotFoundException {199. // Object obj = "";200. Integer[] obj = { 1, 3, 4 };201.202. // // object to bytearray203. ByteArrayOutputStream bo = new ByteArrayOutputStream();204. ObjectOutputStream oo = new ObjectOutputStream(bo);205. oo.writeObject(obj);206. byte[] bytes = bo.toByteArray();207. bo.close();208. oo.close();209. System.out.println(Arrays.toString(bytes));210.211. Integer[] intArr = (Integer[]) testByteArray2Object(bytes);212. System.out.println(Arrays.asList(intArr));213.214.215. byte[] b2 = intToByte(123);216. System.out.println(Arrays.toString(b2));217.218. int a = byteToInt(b2);219. System.out.println(a);220.221. }222.223. /**224. * 字节数组到object的转换.225. */226. private Object testByteArray2Object(byte[] bytes) throws IOException,227. ClassNotFoundException {228. // byte[] bytes = null;229. Object obj;230. // bytearray to object231. ByteArrayInputStream bi = new ByteArrayInputStream(bytes);232. ObjectInputStream oi = new ObjectInputStream(bi);233. obj = oi.readObject();234. bi.close();235. oi.close();236. System.out.println(obj);237. return obj;238. }239.240. }。

【转】Base64算法详解

【转】Base64算法详解原⽂链接：完整的BASE64定义可见和。

编码后的数据⽐原始数据略长，为原来的4/3。

在电⼦邮件中，根据规定，每76个字符，还需要加上⼀个回车换⾏。

可以估算编码后数据长度⼤约为原长的135.1%。

转换的时候，将三个byte的数据，先后放⼊⼀个24bit的缓冲区中，先来的byte占⾼位。

数据不⾜3byte的话，于缓冲器中剩下的⽤0补⾜。

然后，每次取出6（因为26=64）个bit，按照其值选择ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/中的字符作为编码后的输出。

不断进⾏，直到全部输⼊数据转换完成。

当原数据长度不是3的整数倍时, 如果最后剩下⼀个输⼊数据（原始数据按3个⼀组，剩下⼀个），在编码结果后加2个“=”；如果最后剩下两个输⼊数据（原始数据按3个⼀组，剩下两个），编码结果后加1个“=”；如果没有剩下任何数据，就什么都不要加，这样才可以保证数据还原的正确性。

例⼦举例来说，⼀段引⽤⾃《》的⽂句：Man is distinguished, not only by his reason, but by this singular passion from other animals, which is a lust of the mind, that by a perseverance of delight in the continued and indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.经过Base64编码之后变成：TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=编码“Man”⽂本M a nASCII编码7797110⼆进制位010011010110000101101110索引1922546Base64编码T W F u在此例中，Base64算法将三个字符编码为4个字符Base64索引表：数值字符数值字符数值字符数值字符0A16Q32g48w1B17R33h49x2C18S34i50y3D19T35j51z4E20U36k5205F21V37l5316G22W38m5427H23X39n5538I24Y40o5649J25Z41p57510K26a42q58611L27b43r59712M28c44s60813N29d45t61914O30e46u62+15P31f47v63/ 如果要编码的字节数不能被3整除，最后会多出1个或2个字节，那么可以使⽤下⾯的⽅法进⾏处理：先使⽤0字节值在末尾补⾜，使其能够被3整除，然后再进⾏Base64的编码。

Byte和byte[]数组

Byte和byte[]数组Byte和byte[]数组，“表⽰⼀个 8 位⽆符号整数, ⼀般为8位⼆进制数”。

Byte是计算机最基础的存储单位和最基础的通讯单位。

⽽所有的类型都是⽀持由byte[]类型转换⽽来。

为什么说Byte是最基础类型那，其实这⾥的关键所在是，计算机最基础的算法是编码，包括媒体⽂件、图⽚、各种⽂档以致计算机算有数据的⽂件展现都是字符串，⽽这些字符串都是由编码得来。

不管你是各种千奇百怪的字符串组成的格式，最终都要根据编码表，字符转换成相对应的⼗进制数字，⽽这相应的⼗进制数字那，就会存储在byte[]数组中(这⾥的⼗进制数是⽤来计算的，存储时会⾃动转换为⼆进制数字存储，程序计算时会按⼗进制计算)。

媒体⽂件、图⽚、各种⽂档等等—》源⽂件由字符串组成，多个字符—》单个字符—》⼗进制数字(根据相应编码)—》byte[]数组(单个字符)—》byte[]数组(多个字符) —》媒体⽂件、图⽚、各种⽂档等等存储单位或通讯单位。

此时这个“单个字符”⼆进制的长度就是根据相应编码得来的，由多个字符组成的byte[]就组成了媒体⽂件、图⽚、各种⽂档等等的源⽂件。

具体如下：UTF-8编码：⼀个英⽂等于⼀个字节，⼀个中⽂（含繁体）等于三个字节。

Unicode编码：⼀个英⽂等于两个字节，⼀个中⽂（含繁体）等于两个字节。

下⾯可以看到UTF-8编码的byte[]数组(C# byte[]默认存储计算为⼗进制)，所以说最终计算机数据是由byte类型组成数据为基础的。

⽹络传输：如果是⾃⼰程序间的对接，byte[]类型理论上就够了（实际上也不够，哈哈），在传输段传输byte[]类型，收取端收取byte[]类型，然后转化为原格式就可以了。

“a张”编码—>byte[0]=97、byte[1]=229、byte[2]=188、byte[3]=160（byte[0]=01100001、byte[1]=11100101、byte[2]=10111100、byte[3]=10100000）—>传输—>收取为byte[]—> 解码“a张”。

字节数组转换成字符串的方法

字节数组转换成字符串的方法在Java中，字节数组是非常常见的数据类型，通常用于存储二进制数据、图像、声音、视频等。

但有时我们需要将字节数组转换成字符串，以便于使用或显示。

在本文中，我们将介绍Java中几种将字节数组转换成字符串的方法，以及它们的优缺点。

1. 通过构造函数Java中的String类提供了可以接收字节数组作为参数的构造函数，该构造函数可以将字节数组转换成字符串，示例如下：```javabyte[] bytes = new byte[]{97, 98, 99};String str = new String(bytes);```通过该方法可以将字节数组转换成字符串，但是需要注意的是，这种方式默认使用系统默认的字符集来对字节数组进行解码为字符串，如果字节数组中包含了非系统默认字符集的字符，则会产生乱码。

2. 通过指定字符集解码为了避免上述问题，我们可以使用String类提供的带有字符集名称的构造函数，可以指定解码字符集。

示例代码如下：```javabyte[] bytes = new byte[]{97, 98, 99};String str = new String(bytes, "UTF-8");```通过指定字符集，我们可以避免因为使用默认字符集导致的编码错误问题。

3. 使用Base64编码另一种将字节数组转换成字符串的方法是使用Base64类进行编码，将字节数组转换成base64编码的字符串。

示例代码如下：```javabyte[] bytes = new byte[]{97, 98, 99};String encodedStr = Base64.getEncoder().encodeToString(bytes); ```使用Base64编码有一个优点，那就是它可以将任意二进制数据转换成纯文本字符串，且不会出现乱码问题。

但是，该方式有一个明显的缺点，就是编码后的字符串长度会比原始字节数组长度增加1/3左右，这会占用更多的存储空间。