一、字节流分类概括
-->1、ByteArrayInputStream /ByteArrayOutputStream(数组字节输入输出)
InputStream/OutputStream -->2、FileInputStream/FileOutputStream(文件字节输入输出流【参考19.03.30文章】)
(四大抽象类之二,与Reader/Writer平辈) -->3、ObjectInputStream/ObjectOutputStream(对象字节输入输出流)
-->4、FilterInputStream/FilterOutputStream(加装饰器的输入/输出流)-----》》
----------------》》4-1：BufferedInputStream/BufferedOutputStream(带缓冲区的字节流) 【参考19.3.30文章】
----------------》》4-2：DataInputStream/DataOutputStream(数据输入/输出流)
----------------》》4-3：【独有】PrintStream打印输出流、处理流
1、ByteArrayInputStream /ByteArrayOutputStream(数组字节输入输出)
/**学习 1、文件数组字节流 (InputStream/OutputStream的亲儿子)
* ByteArrayInputStream /ByteArrayOutputStream(文件数组字节输入输出)与FileInputStream/FileOutputStream平辈
* 以前源头：本地电脑硬盘文件<-----操作系统----->Java虚拟机 。以前的FileInputStream/FileOutputStream的用法
* 所以每次都要通知操作系统释放内存
* 现在源头：本地电脑的另外一块内存/网络上的一块内存/远程服务器的一块内存 ，看成一块字节数组，所以可以让Java虚拟机直接访问
* 与操作系统无关，使用完后由垃圾回收机制管理，不用释放内存。风格统一，可以释放内存，是实际没作用。
* 1、任何东西都可以转成字节数组 2、字节数组不要太大
*
* 写数据：ByteArrayOutputStream
* 不需要指定文件目的地，这点与FileOutputStream(如需要自己指定个"dest.txt")不同,因为是内存写的，大小不好管理
* 可以不用释放操作
*
*/
package cn.sxt.test; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException; public class Test_0401_ArrayStream {
public static void main(String[] args) throws IOException {
//1、创建源 字符串，编码成字节数组
byte[] src="I am angry,Are you OK!".getBytes();
//2、选择流
ByteArrayInputStream bStream=new ByteArrayInputStream(src);
//3、选择操作
int len=0;
/*3-1： 不借助数组，简单粗暴
while ((len=bStream.read())!=-1) { //等于说读一个字节输出一个字节
System.out.print((char)len);
}*/
//4、可以释放内存，保持统一 ，但其方法是个空方法 ，没什么卵用
bStream.close();
//3-2 ：借助数组，常用方法
byte butter[] =new byte[5];
/*
while ((len=bStream.read(butter))!=-1) {//往butter读取每5个字符，解码换行输出一回。 循环往复
String msg=new String(butter,0,butter.length);
System.out.println(msg);
}*/ //-------------分隔符----写数据(往内存中写，这里内存实际就是输出流的缓冲区)--- ByteArrayOutputStream bStream2=new ByteArrayOutputStream();//默认构建一个32字节的缓冲区,且内容会自动增加)
bStream2.write(src);//把经过编码后的字节src 写入到内存中，也就是输出流缓冲区
byte[] dest=bStream2.toByteArray();//向缓冲区取数据
System.out.println(dest.length+"-->>"+new String(dest,0,dest.length));//数据展示 } }
【综合练习-复制图片】
/** 复制一张图片 所有东西都能读到字节数组中
* 前面4种流的综合
* ByteArrayInputStream /ByteArrayOutputStream FileInputStream/FileOutputStream
* 图片---FileInputStream------->(借助程序作中转，Java虚拟机)---ByteArrayOutputStream------>字节数组中(内存)
* 字节数组(内存)----ByteArrayInputStream---->(借助程序作中转，Java虚拟机)---FileOutputStream-------->图片
*
*/
package cn.sxt.test; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class Test_0401_CopyImage {
public static void main(String[] args) throws IOException {
byte[] srcFile= fileToByteArray("SongYi.jpg");
System.out.println(srcFile.length);//输出源文件图片的大小
ByteArrayToFile(srcFile, "SongYi_copy.jpg"); }
//1、图片到字节数组 传进去一个源文件路径。 图片-->程序--->字节数组
public static byte[] fileToByteArray(String srcFilePath) throws IOException { InputStream iStream=new FileInputStream(srcFilePath);//图片-->程序
ByteArrayOutputStream oStream=new ByteArrayOutputStream();//程序-->字节数组
byte buffer[]=new byte[1024*10]; //缓冲数组
int len=0; //分段读取
while ((len=iStream.read(buffer))!=-1) {
oStream.write(buffer,0,len); }
iStream.close(); return oStream.toByteArray(); } //2、字节数组到图片 字节数组--->程序--->要复制的图片
public static void ByteArrayToFile(byte[] src,String destFilePath) throws IOException { ByteArrayInputStream iStream1=new ByteArrayInputStream(src);//字节数组-->程序 OutputStream oStream1=new FileOutputStream(destFilePath);//程序--->要复制的图片 byte buffer1[]=new byte[1024*10]; //缓冲数组
int len=0; //分段读取
while ((len=iStream1.read(buffer1))!=-1) {
oStream1.write(buffer1,0,len);
}
oStream1.close();
} }
2、ObjectInputStream/ObjectOutputStream(对象字节输入输出流)
当两个进程远程通信时，彼此可以发送各种类型的数据。 无论是何种类型的数据，都会以二进制序列的形式在网络上传送。
比如，我们可以通过http协议发送字符串信息;我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，
才能在网络上传送;接收方则需要把字节序列再恢复为Java对象才能正常读取。把Java对象转换为字节序列的过程称为对象的序列化。
把字节序列恢复为Java对象的过程称为对象的反序列化。
对象序列化的作用有如下两种：
1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器session管理，hibernate将对象持久化实现。
2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。
【代码示例】
/**2、对象流 ObjectStream
* 输出流：序列化
* 输入流：反序列化
*ObjectOutputStream 对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，
*把得到的字节序列写到一个目标输出流中。这个目标输入流可能是文件，数据库，内存中。
*
ObjectInputStream 对象输入流，它的readObject()方法从一个源输入流中读取字节序列
，再把它们反序列化为一个对象，并将其返回。 只有实现了Serializable接口的类的对象才能被序列化。 Serializable接口是一个空接口，只起到标记作用。
*
* 不是所有的对象都可序列化
*/
package cn.sxt.test; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.PrivateKey;
import java.util.Date; import javax.tools.JavaCompiler; public class Test_0401_ObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException { ByteArrayOutputStream baos=new ByteArrayOutputStream();
ObjectOutputStream dos=new ObjectOutputStream(baos); dos.writeUTF("编码");
dos.writeInt(345);
//写入：序列化
dos.writeObject("编码好痛苦");//字符串也是一个对象
dos.writeObject(new Date());
dos.writeObject(new Employee("李白",3458.4)); dos.flush(); //错误原因：byte[] datas=baos.toByteArray();放在了oos.writeInt(14);oos.flush();的前边,应该在后边
byte[] datas=baos.toByteArray(); //DataInputStream dis=new DataInputStream(new ByteArrayInputStream(datas)); ByteArrayInputStream bis=new ByteArrayInputStream(datas);
ObjectInputStream dis=new ObjectInputStream(bis); //读取 ：反序列化
String msg=dis.readUTF();
System.out.println(msg);
System.out.println(dis.readInt());
System.out.println(dis.readObject());
System.out.println(dis.readObject());
//System.out.println(dis.readObject());
//同理前边的字符串类也可以这样操作
Object employee=dis.readObject();
if (employee instanceof Employee) {//如果employee 是Employee类的实例化对象则输出
Employee employeetemp=(Employee)employee;//而且可以强制转换一下
System.out.println(employeetemp); System.out.println("名字："+employeetemp.getName());
//可以看出薪水的属性加了transient透明修饰,这里的返回值为0.0
System.out.println("薪水："+employeetemp.getSalary()); } } } //自己定义的一个类,称之为Javabean封装数据用的。这里还必须要序列化(Serializable)，加个牌照，否则虚拟机后拦截的
class Employee implements java.io.Serializable{
private String name; private transient double salary;//transient:短暂的，临时的 这里翻译为透明的、隐身的.敏感数据可以用。这里不需要序列化 //按键alt+shift+s 出现上面菜单 无参构造 : 快捷键 下边 Generate Constructors from Supperclass..
//.根据基类的构造函数生成构造函数，生成和基类参数相同的构造函数，并同时调用基类的构造函数。
public Employee() {
super();
} //构造方法 Generate Constructor using Fields...
// 使用类属性生成构造函数，就是说会生成使用你定义好的属性作为参数的构造函数。
public Employee(String name, double salary) {
super();
this.name = name;
this.salary = salary;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public double getSalary() {
return salary;
} public void setSalary(double salary) {
this.salary = salary;
} //重写 toString 方法
public String toString() {
return "雇员 [name=" + name + ", salary=" + salary + "]";
} }
4-2：DataInputStream/DataOutputStream(数据输入/输出流)
【代码示例】
/**
*4-2：DataInputStream/DataOutputStream(数据输入/输出流)
*用途：方便处理8大基本数据类型
*1) 先写出后读取
*2) 读取顺序和写出保持一致
*
*/
package cn.sxt.test; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class Test_0401_DataStream {
public static void main(String[] args) throws IOException {
//先搞个节点流ByteArrayInputStream /ByteArrayOutputStream或FileInputStream/FileOutputStream
//然后让装饰流去操作他们，否则装饰流就是无源之水，无本之木。//默认构建一个32字节的缓冲区,且内容会自动增
//ByteArrayOutputStream bos=new ByteArrayOutputStream();//这个流不用关闭 //写出,使用数组作为节点流时
FileOutputStream out = new FileOutputStream("D:/a1.txt");
DataOutputStream dos=new DataOutputStream(out); //byte[] datas=bos.toByteArray();//转成字节放在字节数组中 dos.writeChar('a');
dos.writeInt(10);
dos.writeDouble(Math.random());
dos.writeBoolean(true);
dos.writeUTF("Are you OK");
dos.flush(); //读取顺序与写入保持一致
//ByteArrayInputStream bis=new ByteArrayInputStream(datas);//从字节数组中读取
FileInputStream in = new FileInputStream("D:/a1.txt");
DataInputStream dis=new DataInputStream(in); System.out.println("char: " + dis.readChar());
System.out.println("int: " + dis.readInt());
System.out.println("double: " + dis.readDouble());
System.out.println("boolean: " + dis.readBoolean());
System.out.println("String: " + dis.readUTF()); dos.close();
dis.close(); //数组作为字节流
/* ByteArrayOutputStream baos=new ByteArrayOutputStream();
DataOutputStream dos=new DataOutputStream(baos); dos.writeUTF("编码");
dos.writeInt(345);
dos.flush(); byte[] datas=baos.toByteArray(); //DataInputStream dis=new DataInputStream(new ByteArrayInputStream(datas)); ByteArrayInputStream bis=new ByteArrayInputStream(datas);
DataInputStream dis=new DataInputStream(bis);*/ } }
4-3：【独有】PrintStream打印输出流、处理流
【代码示例】
/**
* 学习4-3：打印流、处理流PrintStream
*
*/
package cn.sxt.test; import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter; public class Test_0401_PrintStream {
public static void main(String[] args) throws FileNotFoundException {
PrintStream pStream=System.out;
pStream.println("人生如逆旅"); //输出内容到控制台
pStream.println(true);
//2个打印流的效果一样
PrintWriter pWriter=new PrintWriter(new FileOutputStream("print3.txt"),true);
pWriter.print("学习Java");
pWriter.close(); FileOutputStream file=new FileOutputStream("print.txt");
PrintStream pStream2=new PrintStream(file,true);//在里面放个字节流 true:使用自动刷新的功能
pStream2.println(false); //输出内容到文件
pStream2.println("人生苦短，学习要趁早！");
pStream2.println("java is best"); //重定向输出端 把原本输出到控制台的输出到文件中去
System.setOut(pStream2);
pStream2.println("改变自己");
//重定向回去控制台 FileDescriptor.out 标准的输入输出端
FileOutputStream file2=new FileOutputStream(FileDescriptor.out);
PrintStream pStream3=new PrintStream(file2,true);
System.setOut(pStream3);
pStream3.println("back"); /*//效果一样
System.setOut(pStream);
pStream.print("回来了");*/ pStream.close();
pStream2.close();
pStream3.close();
} }