学习心得------java学习笔记IO流（1）之字节流

参考自https://blog.csdn.net/qq_36962144/article/details/79815457
（初次写博客，如有不对的地方请指出，我一定吸取教训）

java之输入输出流（IO）之的原理

IO流是用来处理设备之间的数据传输，是以流的方式来处理。可以想象成数据就是管道里的水，而要让水从一个地方流到另一个地方，就需要用到水管了、也就是这里的IO
JDK中相关的包和类都集中在java.io包中。

流的分类

java中按单位可分为 字节流（Byte Stream）和字符流（Char Stream）
流按方向分为 输入流（InputStream / Reader）和输出流（OutputStream / Writer）

（注意：判断输入流还是输出流以程序为参照物）

字节流

下面是各个方法的基本代码

文件字节流（FileInputStream 和 FileInputStream）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileByteCopy {
	public static void main(String[] args) {
		
		try {
			FileInputStream fis = new FileInputStream("src\\练习\\IO\\FileByteCopy.java");
			//FileInputStream fis = new FileInputStream("String name , boolean append");   //append默认false（覆盖）
			FileOutputStream fos = new FileOutputStream("c:\\FileCopy.txt");
			System.out.println("文件大小："+fis.available());
			
			int b = 0;
			//1、一个字节一个字节地读、写，直到文件结尾-1，效率低
			while((b=fis.read())!=-1) {
				fos.write(b);
			}
			
//			//2、一次读取一个数组的数据，效率高
//			byte[] ba = new byte[1024];
//			while((b=fis.read(ba))!=-1) {
//				fos.write(ba , 0 ,ba.length-1);
//			}
			
			fos.close();
			fis.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件找不到");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

基本数据流（DataInputStream 和 DataInputStream）

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 演示了通过DataOutputStream向文件流写8种基本数据类型和String类型的数据
 * 然后通过DataInputStream从文件读取前面写入的数据
 * @author Administrator
 *
 */
public class DataStreamTest {
	public static void main(String[] args) {
		try {
			//将8种基本类型写入文件
			FileOutputStream fos = new FileOutputStream("c:\\copy.txt");
			DataOutputStream dos = new DataOutputStream(fos);
			dos.writeByte((byte)123);
			dos.writeShort((short)12345);
			dos.writeInt(1234566789);
			dos.writeLong(65415641314L);
			dos.writeFloat(2.984f);
			dos.writeDouble(3.1415926);
			dos.writeChar('W');
			dos.writeBoolean(true);
			dos.writeUTF("我的博客");
			
			//读取
			FileInputStream fis = new FileInputStream("c:\\copy.txt");
			DataInputStream dis = new DataInputStream(fis);
			System.out.println(dis.readByte());
			System.out.println(dis.readShort());
			System.out.println(dis.readInt());
			System.out.println(dis.readLong());
			System.out.println(dis.readFloat());
			System.out.println(dis.readDouble());
			System.out.println(dis.readChar());
			System.out.println(dis.readBoolean());
			System.out.println(dis.readUTF());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

对象流（ObjectInputStream 和 ObjectOutputStream）
（Student类必须实现Serializable接口，并重写toString()方法）

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Student implements Serializable{
	private static final long serialVersionUID = 1L;
	transient int id;
	static int age;
	private String name;
	String dept;
	public Student(int id, String name,int age,String dept) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.dept = dept;
	}
	@Override
	public String toString() {
		return "Student [id = "+id+" ,name=" + name + ", dept=" + dept + " ,age = "+age+"]";
	}
	
	
}
public class ObjectStream {
	//存储对象
	public void saveObj() {
		Student stu = new Student(2017564,"猪鸭",18,"CSD");
		try {
			FileOutputStream fos = new FileOutputStream("c:\\stu.ser");
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(stu);
			oos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//读取对象
	public void readObj() {
		Student stu;
		try {
			FileInputStream fis = new FileInputStream("c:\\stu.ser");
			ObjectInputStream ois = new ObjectInputStream(fis);
			stu = (Student)ois.readObject();
			System.out.println(stu);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		ObjectStream os = new ObjectStream();
		os.saveObj();
		os.readObj();
	}
}

管道流（PipedInputStream 和 PipedOutputStream）
//管道流一般实现线程之间的通信（上图忘记加了，请谅解）

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

/**
 * 本程序定义了发送线程Sender、接收线程Receive，然后Sender通过建立好的管道向
 * Receive发送一个String
 * @author Administrator
 *
 */
class Sender implements Runnable{
	private PipedOutputStream out = null;
	
	public Sender(PipedOutputStream out) {
		this.out = out;
	}
	
	@Override
	public void run() {
		String str = "天王盖地虎";
		try {
			out.write(str.getBytes());
			out.close();
			System.out.println("发送线程已经发送："+str+"到管道！");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class Receive implements Runnable{
	private PipedInputStream in = new PipedInputStream();

	public PipedInputStream getInputStream() {
		return in;
	}
	
	@Override
	public void run() {
		byte[] b = new byte[1024];
		try {
			int num = in.read(b);
			in.close();
			if(-1 == num) {
				System.out.println("接收线程：什么都没收到");
			}else {
				System.out.println("接收线程收到："+new String(b,0,num)+"!");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

public class PipeStreamDemo {
	public static void main(String[] args) throws IOException {
		PipedOutputStream out = new PipedOutputStream();
		PipedInputStream in = new PipedInputStream();
		
		Sender sender = new Sender(out);
		Receive receive = new Receive();
		
		in = receive.getInputStream();
		out.connect(in);
		
		new Thread(sender).start();;
		new Thread(receive).start();;
	}
}