inputStream和String,Byte之间的转换
byte数组转换成string的方法积累
byte 数组转换成string 的方法积累.net 的加密算法，返回的都是byte[] 类型，在存贮起来让人非常头疼，最简单的方法就是把byte[] 转换成string 来存贮，当然如果数据量大的话，另当别论。
所以我就把byte[] 转换成string 的方法做一个简单的积累与分析。
目前有 3 种我觉得比较简单的方案来进行转化。
1.Convert.ToBase64String 与Convert.FromBase64String 此方法简单实用。
转换成的string 包含：26 个英文字母的大小写、+、/、0~9 的数字，总共64 个字符。
一般会在结尾出现“ =”。
分析其原因很简单。
原理：用64 个字符来描述6bit 的二进制。
方式：把byte 数据连在一起，以6bit 为单位进行分组，使用64个字符描述6bit数据，如果分组不足6bit,使用“=”补全 2.自己写代码，使用16 进制字符0~9、A~F 来描述数据。
原理：使用16 个字符来描述4bit 的二进制。
也就是说，个byte 要使用两个16 进制字符来进行描述。
方式：对每一byte 的前半部分与后半部分分别用字符来描述。
此方法需要自己手动进行书写，代码相当简单。
可以Crtl+c Ctrl+v 拿来就用。
public static string ByteToString(byte[] bytes)StringBuilder strBuilder = new StringBuilder();foreach (byte bt in bytes) strBuilder.AppendFormat("{0:X2}", bt);return strBuilder.ToString();public static byte[] StringToByte(string str){byte[] bytes = new byte[str.Length / 2];for (int i = 0; i < str.Length / 2; i++) int btvalue = Convert.ToInt32(str.Substring(i * 2, 2), 16);bytes[i] = (byte)btvalue;return bytes;3.使用Encoding 的编码自动转化Encoding.GetEncoding(" 编码格式").GetString() 和Encoding.GetEncoding(" 编码格式").GetBytes()原理：使用编辑规则强行转换。
IO操作手册
IO操作手册1 IO API1.1 类文件输入流：FileReader BufferedReader字符流：输出流：FileWriter BufferedWriter PrintWriter输出流：FileOutputStream BufferedOutputStream PrintStream 字节流：DataOutputStream输入流：FileInputStream BufferedInputStream DataInputStream输入流：InputStreamReader字符字节通用流：输出流：OutputStreamWriter在数据流操作过程中通过缓冲区能大大提高I/O性能，采用数据缓冲区只需将输入与输出流用Buffered*封装一次即可1.2 类说明FileOutputStream 用于写入诸如图像、文件数据之类的原始字节的流FileInputStream 用于读取诸如图像、文件数据之类的原始字节流DataOutputStream写入java基本类型数据字节流（也可写入文件数据）readUTF方法用于读取用UTF-8 修改版格式编码的字节流DataInputStream 读写由DataOutputStream写入的java的基本类型的方法，如readInt,readLong。
writeUTF方法采用平台无关方式的UTF-8 修改版编码写入字节流Buffered*能够在内存里建立一个缓冲数据区,当写文件的时候,能起到缓冲的作用，并且可以自定缓冲区大小，BufferedOutputStream(OutputStream out, int size) InputStreamReader 是从字节流到字符流的桥梁：它读入字节，并根据指定字符编码方式，将之转换为字符流显示。
使用的编码方式可能由名称指定，如InputStreamReader(InputStream in, String charsetName)，charsetName就是用于指定字符编码方式的OutputStreamWriter 是字符流通向字节流的桥梁：使用指定的编码方式将要向其写入的字符编码为字节。
java byte转string的方法
java byte转string的方法Java中byte类型是一种8位的有符号整数类型，范围为-128到127。
在某些情况下，我们需要将byte类型转换为String类型。
本文将介绍几种Java中将byte转换为String的方法。
方法一：使用String的valueOf方法String类中的valueOf方法可以将任意类型的数据转换为String类型。
我们可以使用valueOf方法将byte类型转换为String类型。
示例代码如下：```javabyte b = 65;String str = String.valueOf(b);System.out.println(str);```输出结果为：```65```方法二：使用String的构造方法String类提供了多个构造方法，其中一个可以接受byte类型的参数。
我们可以使用这个构造方法将byte类型转换为String类型。
示例代码如下：```javabyte b = 65;String str = new String(new byte[]{b});System.out.println(str);```输出结果为：```A```方法三：使用Byte的toString方法Byte类是byte的包装类，它提供了一个toString方法，可以将byte类型转换为String类型。
示例代码如下：```javabyte b = 65;String str = Byte.toString(b);System.out.println(str);```输出结果为：```65```方法四：使用StringBuilder类StringBuilder类是一个可变的字符串类，它提供了append方法用于字符串的拼接。
我们可以使用append方法将byte类型的数据拼接成一个字符串。
示例代码如下：```javabyte b = 65;StringBuilder sb = new StringBuilder();sb.append(b);String str = sb.toString();System.out.println(str);```输出结果为：```65```方法五：使用String的format方法String类提供了一个format方法，可以使用格式化字符串将byte类型转换为String类型。
byte转fileinputstream方法
byte转fileinputstream方法【最新版3篇】目录（篇1）1.概述2.byte 转 FileInputStream 方法的实现3.示例代码4.优点与局限性5.总结正文（篇1）1.概述在 Java 编程语言中，byte 数组是一种常见的数据结构，用于存储原始字节数据。
而在处理文件时，常常需要将 byte 数组转换为FileInputStream，以便进行更高级的文件操作。
本文将介绍如何实现byte 转 FileInputStream 方法。
2.byte 转 FileInputStream 方法的实现要实现 byte 转 FileInputStream 方法，首先需要创建一个FileInputStream 对象，然后将 byte 数组写入该对象。
以下是一个简单的示例代码：```javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;import java.nio.file.Files;import java.nio.file.Paths;public class ByteToFileInputStream {public static void main(String[] args) throws IOException {byte[] data = "Hello, World!".getBytes();Paths filePath = Paths.get("output.txt");// 将 byte 数组写入 FileInputStreambyteToFileInputStream(data, filePath);}public static void byteToFileInputStream(byte[] data, Paths filePath) throws IOException {try (OutputStream outputStream =Files.newOutputStream(filePath)) {outputStream.write(data);}}}```3.示例代码在上面的示例代码中，我们首先将一个包含"Hello, World!"字符串的 byte 数组传递给 byteToFileInputStream 方法。
常用流
流机制是JAVA及C++中的一个重要的机制，通过流能使我们能自由地控制包括文件，内存，IO设备等等中的数据的流向。
如：可以从文件输入流中获取数据，经处理后再通过网络输出流把数据输出到网络设备上；或利用对像输出流把一个程序中的对象输出到一个格式流文件中，并通过网络流对象将其输出到远程机器上，然后在远程机器上利用对象输入流将对象还原。
像这些机制是别的高级语言所不能比拟的。
但要掌握好这些流对象，流的概念是很重要的。
流是一串连续不继的数据的集合，就像水管一里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。
数据写入程序可以是一段一段地向数据流管道中写入数据，这些数据段会按先向顺序形成一个长的数据流。
对数据的读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。
不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。
在JAVA中的流按流动方向可以分为输入流及输出流两种，按流的处理位置可分为节点流和包装流。
输入流，输出流是以程序为参考点来说的，所谓的输入流就是程序从中获取数据的流，输出流就是程序要其写数据的流。
在输入流的一边是程序，而另一边就是流的数据源。
而输出流的一边则目标，一边就是程序。
其实流可以想像成是一条长河，在上游有一水库提供水源，河边住着一户人，随时都可以从河边取到水，同时，这户人也可以把一些废水倒进河里，使得废水可以流进大海。
这里所提到河就是一个数据的流动通道，而水库就好比是计算机上的一切数据源，包括磁盘文件，内存，IO设备，键盘等等，JAVA提供了非常完善的输入流类来把这些数据源挂接到流上使得程序能从这些输入流中获取所需的数据。
河边上的用户就是程序，它能随时随地从流中取得数据，只要有数据源挂接到这个通道上可以。
而大海就是程序处理完数据后要流向的目的地，这些目的地包抱磁盘文件，内存，IO设备，显示器等，这些目的地只是相对程序来说的，它们也可能是别的进程的输入流。
BufferedImage转换InputStream byte数组转化成16进制
BufferedImage转换InputStream byte数组转化成16进制字符串,iOS 获取当前手机系统语言, 获取当前网路连接情况 ,iOS 进入一个类最先调用和只调用一次的方法iOS 属性简谈readwrite、readonly、retain、copy、a i 限制textField字节长度heckbox 选中、取值处理 css3实现文本溢出显示省略号system("pause");return 0;}[代码] [C/C++]代码// Client.cpp : 定义控制台应用程序的入口点。
//iOS调用 objc_msgSend 报错解决办法// iOS系统自带各平台分享#include "stdafx.h"#include <boost/asio.hpp>#include <boost/shared_ptr.hpp>#include <boost/thread.hpp>#include <iostream>#include <windows.h>//iOS应用贝塞尔曲线画各种曲线折线，和进度条，动画进度//**************************************************************欢迎c c++ windows驱动爱好者服务器程序员沟通交流**************************************************************/using namespace boost::asio;using namespace std;const size_t defaultLoopTime = 10000;const size_t defaultSendLength = 1024 * 10 * 50;const short int defaultPort = 8001;int main(){io_service service;ip::tcp::endpoint ep(ip::address::from_string("192.168.3.79"), defaultPort); ip::tcp::socket sock(service);sock.connect(ep);time_t timer1;time(&timer1);try {for (size_t i = 0; i < defaultLoopTime; i++){boost::shared_ptr<char> msgPtr(new char[defaultSendLength]);boost::system::error_code ec;size_t bytes = read(sock, buffer(msgPtr.get(), defaultSendLength), ec);assert(bytes == defaultSendLength);if (ec == boost::asio::error::eof)break; // Connection closed cleanly by peer.else if (ec)throw boost::system::system_error(ec); // Some other error.}}catch (std::exception& e){std::cerr << e.what() << std::endl;return -1;}[代码] [Google Go]代码package mainimport ("io/ioutil""net/http""net/""fmt""encoding/json")//----------------------------------// 黄金数据调用示例代码－聚合数据// 在线接口文档：www/docs/29//----------------------------------const APPKEY = "*******************" //您申请的APPKEYfunc main(){//1.上海黄金交易所Request1()//2.上海期货交易所Request2()//3.银行账户黄金Request3()}//1.上海黄金交易所func Request1(){//请求地址juhe :="web:8080/finance/gold/shgold"//初始化参数param:=.Values{}//配置请求参数,方法内部已处理encode问题,中文参数可以直接传参param.Set("key",APPKEY) //APP Keyparam.Set("v","") //JSON格式版本(0或1)默认为0//发送请求data,err:=Get(juhe,param)if err!=nil{fmt.Errorf("请求失败,错误信息:\r\n%v",err)}else{var netReturn map[string]interface{}json.Unmarshal(data,&netReturn)if netReturn["error_code"].(float64)==0{fmt.Printf("接口返回result字段是:\r\n%v",netReturn["result"]) }}}//2.上海期货交易所func Request2(){//请求地址juhe :="web:8080/finance/gold/shfuture"//初始化参数param:=.Values{}//配置请求参数,方法内部已处理encode问题,中文参数可以直接传参param.Set("key",APPKEY) //APP Keyparam.Set("v","") //JSON格式版本(0或1)默认为0//发送请求data,err:=Get(juhe,param)if err!=nil{fmt.Errorf("请求失败,错误信息:\r\n%v",err)}else{var netReturn map[string]interface{}json.Unmarshal(data,&netReturn)if netReturn["error_code"].(float64)==0{fmt.Printf("接口返回result字段是:\r\n%v",netReturn["result"]) }}}//3.银行账户黄金func Request3(){//请求地址juhe :="web:8080/finance/gold/bankgold"//初始化参数param:=.Values{}//配置请求参数,方法内部已处理encode问题,中文参数可以直接传参param.Set("key",APPKEY) //APP Key//发送请求data,err:=Get(juhe,param)if err!=nil{fmt.Errorf("请求失败,错误信息:\r\n%v",err)}else{var netReturn map[string]interface{}json.Unmarshal(data,&netReturn)if netReturn["error_code"].(float64)==0{fmt.Printf("接口返回result字段是:\r\n%v",netReturn["result"]) }}}// get 网络请求func Get(api string,params .Values)(rs[]byte ,err error){var *.,err=.Parse(api)if err!=nil{fmt.Printf("解析错误:\r\n%v",err)return nil,err}//如果参数中有中文参数,这个方法会进行Encode.RawQuery=params.Encode()resp,err:=http.Get(.String())if err!=nil{fmt.Println("err:",err)return nil,err}defer resp.Body.Close()return ioutil.ReadAll(resp.Body)}// post 网络请求 ,params 是.Values类型func Post(api string, params .Values)(rs[]byte,err error){resp,err:=http.PostForm(api, params)if err!=nil{return nil ,err}defer resp.Body.Close()return ioutil.ReadAll(resp.Body)}代码描述：基于GO的黄金数据接口调用代码实例关联数据：黄金数据[代码] [C#]代码using System;using System.Collections.Generic;using System.Linq;using System.Text;using ;using System.IO;using ;using System.Diagnostics;using System.Web;//----------------------------------// 黄金数据调用示例代码－聚合数据// 在线接口文档：www/docs/29// 代码中JsonObject类下载地址:/download/gcm3206021155665/7458439//----------------------------------namespace ConsoleAPI{class Program{static void Main(string[] args){string appkey = "*******************"; //配置您申请的appkey//1.上海黄金交易所string 1 = "web:8080/finance/gold/shgold";var parameters1 = new Dictionary<string, string>();parameters1.Add("key", appkey);//你申请的keyparameters1.Add("v" , ""); //JSON格式版本(0或1)默认为0string result1 = sendPost(1, parameters1, "get");JsonObject newObj1 = new JsonObject(result1);String errorCode1 = newObj1["error_code"].Value;if (errorCode1 == "0"){Debug.WriteLine("成功");Debug.WriteLine(newObj1);}else{//Debug.WriteLine("失败");Debug.WriteLine(newObj1["error_code"].Value+":"+newObj1["reason"].Value); }//2.上海期货交易所string 2 = "web:8080/finance/gold/shfuture";var parameters2 = new Dictionary<string, string>();parameters2.Add("key", appkey);//你申请的keyparameters2.Add("v" , ""); //JSON格式版本(0或1)默认为0string result2 = sendPost(2, parameters2, "get");JsonObject newObj2 = new JsonObject(result2);String errorCode2 = newObj2["error_code"].Value;if (errorCode2 == "0"){Debug.WriteLine("成功");Debug.WriteLine(newObj2);}else{//Debug.WriteLine("失败");Debug.WriteLine(newObj2["error_code"].Value+":"+newObj2["reason"].Value);}//3.银行账户黄金string 3 = "web:8080/finance/gold/bankgold";var parameters3 = new Dictionary<string, string>();parameters3.Add("key", appkey);//你申请的keystring result3 = sendPost(3, parameters3, "get");JsonObject newObj3 = new JsonObject(result3);String errorCode3 = newObj3["error_code"].Value;if (errorCode3 == "0"){Debug.WriteLine("成功");Debug.WriteLine(newObj3);}else{//Debug.WriteLine("失败");Debug.WriteLine(newObj3["error_code"].Value+":"+newObj3["reason"].Value);}}/// <summary>/// Http (GET/POST)/// </summary>/// <param name="">请求</param>/// <param name="parameters">请求参数</param>/// <param name="method">请求方法</param>/// <returns>响应内容</returns>static string sendPost(string , IDictionary<string, string> parameters, string method){if (method.ToLower() == "post"){HttpWebRequest req = null;HttpWebResponse rsp = null;System.IO.Stream reqStream = null;try{req = (HttpWebRequest)WebRequest.Create();req.Method = method;req.KeepAlive = false;req.ProtocolVersion = HttpVersion.Version10;req.Timeout = 5000;req.ContentType ="application/x-www-form-encoded;charset=utf-8";byte[] postData =Encoding.UTF8.GetBytes(BuildQuery(parameters, "utf8"));reqStream = req.GetRequestStream();reqStream.Write(postData, 0, postData.Length);rsp = (HttpWebResponse)req.GetResponse();Encoding encoding = Encoding.GetEncoding(rsp.CharacterSet); return GetResponseAsString(rsp, encoding);}catch (Exception ex){return ex.Message;}finally{if (reqStream != null) reqStream.Close();if (rsp != null) rsp.Close();}}else{//创建请求HttpWebRequest request = (HttpWebRequest)WebRequest.Create( + "?" + BuildQuery(parameters, "utf8"));//GET请求request.Method = "GET";request.ReadWriteTimeout = 5000;request.ContentType = "text/html;charset=UTF-8";HttpWebResponse response =(HttpWebResponse)request.GetResponse();Stream myResponseStream = response.GetResponseStream();StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));//返回内容string retString = myStreamReader.ReadToEnd();return retString;}}/// <summary>/// 组装普通文本请求参数。
Java中InputSteam怎么转String
Java中InputSteam怎么转StringInputSteam与String相互转化字符串被⼴泛应⽤于 Java 编程中，是程序经常处理的对象。
以对象的⽅式处理字符串，使字符串更加⽅便灵活。
Java 提供了 String 类创建和操作字符串，当我们从⽂件中读取数据时，常常需要将 InputStream 转换为 String，以便于下⼀步的处理。
1.使⽤ InputStreamReader 和 StringBuilder (JDK)public class InputStream2String {public static void main(String[] args) {try {InputStream inputStream = new FileInputStream("E:/duckAndJava/IO/testFile.txt"); //路径修改为本地⽂件所在的位置char[] buffer = new char[1024]; //根据需要的数组⼤⼩进⾏⾃定义StringBuilder out = new StringBuilder();Reader in = new InputStreamReader(inputStream, "UTF-8");for (int numRead; (numRead = in.read(buffer, 0, buffer.length)) > 0; ) {out.append(buffer, 0, numRead);}String myString = out.toString();System.out.println("myString = " + myString);}catch (IOException e){e.printStackTrace();}}2.使⽤ inputStream.read() and StringBuilderStringBuilder sb = new StringBuilder();for (int ch; (ch = inputStream.read()) != -1; ) {sb.append((char) ch);}String myString = sb.toString();3.使⽤ ByteArrayOutputStream and inputStream.readByteArrayOutputStream result = new ByteArrayOutputStream();byte[] buffer = new byte[1024];for (int length; (length = inputStream.read(buffer)) != -1; ) {result.write(buffer, 0, length);}String myString = result.toString("UTF-8");4.使⽤ BufferedInputStream 和 ByteArrayOutputStreamBufferedInputStream bis = new BufferedInputStream(inputStream);ByteArrayOutputStream buf = new ByteArrayOutputStream();for (int result = bis.read(); result != -1; result = bis.read()) {buf.write((byte) result);}String myString = buf.toString("UTF-8");5.使⽤ BufferedReaderString newLine = System.getProperty("line.separator");BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));StringBuilder result = new StringBuilder();for (String line; (line = reader.readLine()) != null; ) {if (result.length() > 0) {result.append(newLine);}result.append(line);}String myString = result.toString();6.使⽤ Stream API 或 parallel Stream APIString myString = new BufferedReader(new InputStreamReader(inputStream)).lines().collect(Collectors.joining("\n"));或String myString = new BufferedReader(new InputStreamReader(inputStream)).lines().parallel().collect(Collectors.joining("\n"));7.使⽤ StringWriter 和IOUtils.copy (Apache Commons)StringWriter writer = new StringWriter();IOUtils.copy(inputStream, writer, "UTF-8");return writer.toString();8.使⽤CharStreams (Google Guava)String result = CharStreams.toString(new InputStreamReader(inputStream, Charsets.UTF_8));分别按照字符串长度来进⾏测试。
byte数组字符串转byte数组
byte数组字符串转byte数组
byte数组字符串转byte数组是一种常见的编码处理技术，广泛应
用于各种软件开发中。
它可以将特定的字符串表示为一个具体的字节
形式，便于在网络传输、存储中进行编码处理和计算。
byte数组字符串转byte数组具体步骤如下：
1、使用String.getBytes(Charset)方法将字符串转换为字节数组，该方法需要提供字符集编码，例如：'UTF-8''GBK'等。
2、通过ByteArrayInputStream将获取到的字节数组作为输入流
来读取，然后依次将字节写入一个byte数组中。
3、通过ByteArrayOutputStream将读取到的字节数组写入输出流，然后将字节数组转为byte[]类型的数组。
4、使用System.arraycopy(src,0,dest,0,length);方法将原字节
数组转换为新的byte[]类型数组。
因此，上述步骤就是字符串转为byte数组的基本思路，可以按照
上述步骤来实现字符串转换为byte数据的功能。
而使用不同的字符集
编码，则可以转换出不同的字节数组，从而实现特定格式转化的目的。
byte转fileinputstream方法
byte转fileinputstream方法在Java编程中，将byte数组转换为FileInputStream对象可以通过不同的方法实现。
以下是一些常见的方法和示例代码，可以参考：方法一：使用ByteArrayInputStream和BufferedInputStream组合```javabyte[] byteArray = { 1, 2, 3, 4, 5 };ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);BufferedInputStream bufferedInputStream = new BufferedInputStream(byteArrayInputStream);FileInputStream fileInputStream = newFileInputStream(bufferedInputStream);```这种方法使用ByteArrayInputStream将byte数组转换为输入流，然后再通过BufferedInputStream对输入流进行缓冲，最后通过FileInputStream包装缓冲输入流得到最终的FileInputStream对象。
方法二：使用File.createTempFile创建临时文件```javabyte[] byteArray = { 1, 2, 3, 4, 5 };File tempFile = File.createTempFile("temp", ".tmp");tempFile.deleteOnExit();try (FileOutputStream fos = new FileOutputStream(tempFile)) {fos.write(byteArray);} catch (IOException e) {e.printStackTrace();}FileInputStream fileInputStream = new FileInputStream(tempFile); ```这种方法是将byte数组写入一个临时文件，然后再通过FileInputStream读取该临时文件得到FileInputStream对象。
(转)java byte与char、String互转原理
（转）java byte与char、String互转原理2009-10-21 19:22转：/bluespot/archive/2008/10/23/1318155.html一、字节和unicodeJava内核是unicode的，就连class文件也是，但是很多媒体，包括文件/流的保存方式是使用字节流的。
因此Java要对这些字节流经行转化。
char是unicode的，而byte是字节。
Java中byte/char互转的函数在sun.io的包中间有。
其中ByteToCharConverter类是中调度，可以用来告诉你，你用的convertor。
其中两个很常用的静态函数是：public static ByteToCharConverter getDefault();public static ByteToCharConverter getConverter(String encoding);如果你不指定converter，则系统会自动使用当前的encoding,gb平台上用gbk,en平台上用8859_1。
byte——〉char："你"的gb码是：0xc4e3 ,unicode是0x4f60String encoding = "gb2312";byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};ByteToCharConverter converter = ByteToCharConverter.getConverter(encoding);char c[] = converter.convertAll(b);for (int i = 0; i < c.length; i++) {System.out.println(Integer.toHexString(c[i]));}结果是什么？0x4f60如果encoding ="8859_1"，结果又是什么？0x00c4,0x00e3如果代码改为：byte b[] = {(byte)'\u00c4',(byte)'\u00e3'};ByteToCharConverter converter = ByteToCharConverter. getDefault();char c[] = converter.convertAll(b);for (int i = 0; i < c.length; i++) {System.out.println(Integer.toHexString(c[i]));}结果将又是什么？这就要根据平台的编码而定。
java IO流
一、IO流的三种分类方式1.按流的方向分为：输入流和输出流2.按流的数据单位不同分为：字节流和字符流3.按流的功能不同分为：节点流和处理流二、IO流的四大抽象类：字符流：Reader Writer字节流：InputStream（读数据）OutputStream（写数据）三、InputStream的基本方法int read（）throws IOException读取一个字节以整数形式返回，如果返回-1已到输入流的末尾void close（）throws IOException关闭流释放内存资源long skip（long n）throws IOException跳过n个字节不读四、OutputStream的基本方法void write（int b）throws IOException向输出流写入一个字节数据void flush（）throws IOException将输出流中缓冲的数据全部写出到目的地五、Writer的基本方法void write（int c）throws IOException向输出流写入一个字符数据void write（String str）throws IOException将一个字符串中的字符写入到输出流void write（String str，int offset，int length）将一个字符串从offset开始的length个字符写入到输出流void flush（）throws IOException将输出流中缓冲的数据全部写出到目的地六、Reader的基本方法int read（）throws IOException读取一个字符以整数形式返回，如果返回-1已到输入流的末尾七、节点流类型点击查看大图八、访问文件之FileInputStream和FileOutputStream继承基类用于向文件中输入输出字节九、访问文件之FileReader和FileWriter继承基类用于向文件中输入输出字符----输出流在构造函数第二个参数可以设置true意义为跟在已有文件后进行输入----此类流会抛出FileNotFoundException需要对其进行显示捕捉十、缓冲流：缓冲流要套接在相应的节点流之上，提高了读写的效率。
String与byte[]字节数组中文转换乱码问题
![String与byte[]字节数组中文转换乱码问题](https://img.taocdn.com/s3/m/4a44471591c69ec3d5bbfd0a79563c1ec4dad75b.png)
String与byte[]字节数组中⽂转换乱码问题Sunshine的 String.getBytes()和new String()在Java中，String.getBytes(String decode)⽅法会根据指定的decode编码返回某字符串在该编码下的byte数组表⽰，如byte[] b_gbk = "中".getBytes("GBK");byte[] b_utf8 = "中".getBytes("UTF-8");byte[] b_iso88591 = "中".getBytes("ISO8859-1");byte[] b_unicode = "中".getBytes("unicode");将分别返回“中”这个汉字在GBK、UTF-8和ISO8859-1编码下的byte数组表⽰，此时b_gbk的长度为2，b_utf8的长度为3，b_iso88591的长度为1,b_unicode 的长度为4（系统的的unicode采⽤的是big-endian就是前⾯是两个字节来表⽰这个的，unicode采⽤的都是两个字节编码，所以后⾯是4个字节）。
⽽与getBytes相对的，可以通过new String(byte[], decode)的⽅式来还原这个“中”字时，这个new String(byte[], decode)实际是使⽤decode指定的编码来将byte[]解析成字符串。
String s_gbk = new String(b_gbk,"GBK");String s_utf8 = new String(b_utf8,"UTF-8");String s_iso88591 = new String(b_iso88591,"ISO8859-1");通过打印s_gbk、s_utf8和s_iso88591，会发现，s_gbk和s_utf8都是“中”，⽽只有s_iso88591是⼀个不认识的字符，为什么使⽤ISO8859-1编码再组合之后，⽆法还原“中”字呢，其实原因很简单，因为ISO8859-1编码的编码表中，根本就没有包含汉字字符，当然也就⽆法通过"中".getBytes("ISO8859-1");来得到正确的“中”字在ISO8859-1中的编码值了，所以再通过new String()来还原就⽆从谈起了。
字符转inputstream方法
字符转inputstream方法字符转InputStream的方法是将字符数据转换成字节数据的过程，使其能够以InputStream的形式被读取和处理。
在Java中，有多种方法可以实现字符转InputStream的功能。
本文将为您一步一步详细介绍几种常用的字符转InputStream的方法。
1. 使用String.getBytes()方法：String类提供了一个getBytes()方法，可以将字符串转换为字节数组。
这个方法有多个重载形式，其中可以指定字符集，这样可以保证转换后的字节数组的编码和源字符串一致。
接下来，我们可以用ByteArrayInputStream将字节数组转换为InputStream。
代码示例：String str = "Hello, world!";byte[] bytes = str.getBytes(); 将字符串转换为字节数组InputStream inputStream = new ByteArrayInputStream(bytes); 字节数组转换为InputStream2. 使用InputStreamReader：InputStreamReader是将InputStream转换为Reader的桥梁，可以指定字符集将字节流转换为字符流。
我们可以利用这一特性，将字节数组转换为InputStream，再将其转换为文本文件的内容。
代码示例：String str = "Hello, world!";InputStream inputStream = newByteArrayInputStream(str.getBytes()); 字节数组转换为InputStream Reader reader = new InputStreamReader(inputStream); InputStream转换为Reader3. 使用Apache Commons IO库：Apache Commons IO是一个开源的Java类库，提供了丰富的I/O操作功能。
c++ byte数组转string的几种方法
c++ byte数组转string的几种方法1. 引言1.1 介绍byte数组和string一个byte数组是由一组连续的字节构成的数据结构，每个字节包含8位二进制数据。
在C++中，byte数组通常使用unsigned char数组来表示。
而string是一个由字符组成的序列，可以包含任意Unicode字符。
将byte数组转换为string是一个常见的操作，有时候我们需要将二进制数据转换为可读的文本格式，或者需要处理网络通信中的字节流数据。
在C++中，有多种方法可以实现这种转换，每种方法都有其适用的场景和优缺点。
在本文中，我们将介绍几种常用的方法来实现byte数组到string 的转换，包括使用stringstream、循环遍历、copy函数、字符串流和bitset。
通过学习这些方法，我们可以更好地应对不同情况下的数据转换需求，提高我们的编程技能和代码质量。
接下来我们将详细介绍这些方法及其应用场景。
1.2 问题背景在C++编程中，经常会遇到将byte数组转换为string的需求。
byte数组是由一组字节按照顺序排列而成，通常用来表示二进制数据。
而string则是一种表示文本数据的数据类型，包含了字符序列。
在实际开发中，我们可能需要将从网络或文件读取的二进制数据转换为可读的文本形式，或者将文本数据按照某种编码格式转换为二进制数据。
byte数组和string之间的转换是一项常见的任务。
在进行byte数组到string的转换时，我们需要考虑到不同的方法和技巧，以及它们的适用场景和性能表现。
本文将介绍几种常用的转换方法，包括使用stringstream、循环遍历、copy函数、字符串流和bitset等方式。
通过比较这些方法的优缺点，我们可以更好地选择适合具体场景的转换方法，提高代码的效率和可维护性。
2. 正文2.1 方法一：使用stringstream在C++中，我们可以使用stringstream来将byte数组转换为string。
Java中字符串与byte数组之间的相互转换
Java中字符串与byte数组之间的相互转换前⾔Java与其他语⾔编写的程序进⾏tcp/ip socket通讯时，通讯内容⼀般都转换成byte数组型，java在字符与数组转换也是⾮常⽅便的。
下⾯跟我⼀起来了解⼀下字符串与byte之间转换的原理原理我们都知道，在Java⾥byte类型是占⽤1个字节，即8位的，⽽16进制的字符占⽤4位，所以每个byte可以⽤两个字符来表⽰，反之亦然。
举个例⼦byte = 123⽤⼆进制表⽰：0111 1011每4位⽤字符表⽰：7 b是的，原理就这么简单，接下来⽤代码实现：byte[] 转16进制字符串⽅法⼀思路：先把byte[] 转换维char[]，再把char[]转换为字符串public static String bytes2Hex(byte[] src) {if (src == null || src.length <= 0) {return null;}char[] res = new char[src.length * 2]; // 每个byte对应两个字符final char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };for (int i = 0, j = 0; i < src.length; i++) {res[j++] = hexDigits[src[i] >> 4 & 0x0f]; // 先存byte的⾼4位res[j++] = hexDigits[src[i] & 0x0f]; // 再存byte的低4位}return new String(res);}⽅法⼆思路：先把byte转换为int类型，再转换为字符串public static String bytesToHex(byte[] src){if (src == null || src.length <= 0) {return null;}StringBuilder stringBuilder = new StringBuilder("");for (int i = 0; i < src.length; i++) {// 之所以⽤byte和0xff相与，是因为int是32位，与0xff相与后就舍弃前⾯的24位，只保留后8位String str = Integer.toHexString(src[i] & 0xff);if (str.length() < 2) { // 不⾜两位要补0stringBuilder.append(0);}stringBuilder.append(str);}return stringBuilder.toString();}16进制字符串转byte[]思路：先把字符串转换为char[] ，再转换为byte[]public static byte[] hexToBytes(String hexString) {if (hexString == null || hexString.equals("")) {return null;}int length = hexString.length() / 2;char[] hexChars = hexString.toCharArray();byte[] bytes = new byte[length];String hexDigits = "0123456789abcdef";for (int i = 0; i < length; i++) {int pos = i * 2; // 两个字符对应⼀个byteint h = hexDigits.indexOf(hexChars[pos]) << 4; // 注1int l = hexDigits.indexOf(hexChars[pos + 1]); // 注2if(h == -1 || l == -1) { // ⾮16进制字符return null;}bytes[i] = (byte) (h | l);}return bytes;}注：注1得到xxxx0000，注2得到0000xxxx，相或就把两个字符转换为⼀个byte了。
字节流和字符流的相互转换
1：字节输入流转换为字符输入流：InputStreamReader是字节流向字符流的桥梁，它使用指定的charset读取字节并将其解码为字符，它使用的字符集可以由名称指定或显示给定。
根据InputStream的实例创建InputStreamReader的方法有4种：InputStreamReader（InputStream in）//根据默认字符集创建InputStreamReader（InputStream in,Charset cs）//使用给定字符集创建InputStreamReader（InputStream in,CharsetDecoder dec）//使用给定字符集解码器创建InputStreamReader（InputStream in,String charsetName）//使用指定字符集创建2：字节输出流转换为字符输出流OutputStreamWriter是字符流通向字节流的桥梁，它使用指定的charset 将要写入流中的字符编码成字节，它使用的字符集可以由名称指定或显示给定，否则将接受默认的字符集：根据根据InputStream的实例创建OutputStreamWriter的方法有4种：OutputStreamWriter（outputstream out）//根据默认的字符集创建OutputStreamWriter（outputstream out,charset cs)//使用给定的字符集创建OutputStreamWriter（outputstream out,charsetDecoder dec)//使用组定字符集创建OutputStreamWriter（outputstream out,String charsetName)//使用指定字符集创建字节流和字符流的相互转换1、从字节流到字符流：InputStreamReader、OutputStreamWriter类可以实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.import java.io.ByteArrayInputStream;
2.import java.io.ByteArrayOutputStream;
3.import java.io.IOException;
4.import java.io.InputStream;
5.
6./**
7. *
8. * @author Andy.Chen
9. * @mail Chenjunjun.ZJ@
10. *
11. */
12.public class InputStreamUtils {
13.
14. final static int BUFFER_SIZE = 4096;
15.
16. /**
17. * 将InputStream转换成String
18. * @param in InputStream
19. * @return String
20. * @throws Exception
21. *
22. */
23. public static String InputStreamTOString(InputStream in) throws Ex
ception{
24.
25. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
26. byte[] data = new byte[BUFFER_SIZE];
27. int count = -1;
28. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
29. outStream.write(data, 0, count);
30.
31.data = null;
32. return new String(outStream.toByteArray(),"ISO-8859-1");
33. }
34.
35. /**
36. * 将InputStream转换成某种字符编码的String
37. * @param in
38. * @param encoding
39. * @return
40. * @throws Exception
41. */
42. public static String InputStreamTOString(InputStream in,Strin
g encoding) throws Exception{
43.
44. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
45. byte[] data = new byte[BUFFER_SIZE];
46. int count = -1;
47. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
48. outStream.write(data, 0, count);
49.
50.data = null;
51. return new String(outStream.toByteArray(),"ISO-8859-1");
52. }
53.
54. /**
55. * 将String转换成InputStream
56. * @param in
57. * @return
58. * @throws Exception
59. */
60. public static InputStream StringTOInputStream(String in) throws Ex
ception{
61.
62. ByteArrayInputStream is = new ByteArrayInputStream(in.getBytes
("ISO-8859-1"));
63. return is;
64. }
65.
66. /**
67. * 将InputStream转换成byte数组
68. * @param in InputStream
69. * @return byte[]
70. * @throws IOException
71. */
72. public static byte[] InputStreamTOByte(InputStream in) throws IOEx
ception{
73.
74. ByteArrayOutputStream outStream = new ByteArrayOutputStream();
75. byte[] data = new byte[BUFFER_SIZE];
76. int count = -1;
77. while((count = in.read(data,0,BUFFER_SIZE)) != -1)
78. outStream.write(data, 0, count);
79.
80.data = null;
81. return outStream.toByteArray();
82. }
83.
84. /**
85. * 将byte数组转换成InputStream
86. * @param in
87. * @return
88. * @throws Exception
89. */
90. public static InputStream byteTOInputStream(byte[] in) throws Exce
ption{
91.
92. ByteArrayInputStream is = new ByteArrayInputStream(in);
93. return is;
94. }
95.
96. /**
97. * 将byte数组转换成String
98. * @param in
99. * @return
100. * @throws Exception
101. */
102. public static String byteTOString(byte[] in) throws Exception{ 103.
104. InputStream is = byteTOInputStream(in);
105. return InputStreamTOString(is);
106. }
107.
108.}。