IO流常规操作

IO流

IO就是输入输出，IO设备在计算机中起着举足轻重的作用，IO流也就是输入输出流，用来交互数据，程序和程序交互，程序也可以和网络等媒介交互。

一、IO流的分类

要分类，肯定得站得不同角度来看这个问题。

• 根据流向划分，分为输入流和输出流
• 根据数据的单位来分划，分为字节流和字符流
• 根据功能划分，分为节点流和包装流
• 还有很多

二、四大基本流

在java中IO流非常之多，但都继承于这四大基流，分别为，字节输入流(InputStream),字节输出流(OutputStream),字符输入流（Reader)和字符输出流(Writer).

它们都是抽象类，不能创建对象，只能创建它们的子类对象，阅读API发现，它们都有一个共同的方法close方法，用来关闭流，如果不关闭流的话程序会一直引用着文件。

三、模板操作

• 创建源和目标
• 创建流对象
• 具体的IO操作
• 关闭流

在下面的例子中穿插讲述

四、文件流

文件流操作是是文件。分为字符流和字节流，字节流操作是所有的二进制文件包括视频啊，图片啊什么的。字符流主要解决的还是中文的一些问题，因为中文多个字节（GBK是2个字节，UTF-8是3个字节），所有可能出现读一半或者写一半就不读了或者不写了，这样就出现乱码了。具体用字符流还是字节流得具体选择，字节流是可以操作字符流的，但是反过来就可能出现问题。输入就是从文件中读到程序中来，而输出就是从程序中输出到文件中。在这样章节记住一句话：读进来，写出去。下面操作一下各个流的常用方法，

• 文件字节输入流(FileInputStream)

  int read() 	从此输入流中读取一个数据字节。 
  int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
  int read(byte[] b, int off, int len)从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
  

  读取文件中所有的数据，用到了一个缓冲数组，也就是每次读取5个字节，直到读完为止有个len返回当前读了几个字节，如果后面没有字节了，那么它就返回-1

  //读取文件中所有的数据
  byte[] buffer = new byte[5];//定义一个缓冲数组长度为5，每次只能读取5个字节
  int len = 0;//当前读取的字节数，没有字节就返回 -1
  while((len = in.read(buffer))!= -1 ){
      String str = new String(buffer,0,len);
      System.out.println(str);
  }
  

• 文件字节输出流(FileOutputStream)

  1.void write(byte[] b) 
  将 b.length 个字节从指定 byte 数组写入此文件输出流中。 
  2.void write(byte[] b, int off, int len)
  将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。 
  3.void write(int b) 
  将指定字节写入此文件输出流。 
  

  输出就是想文件中写数据，可以一次写一个字节，也可以写一个数组中的元素，这个比较简单。可以用一下四个步骤操作一下

  
  public class FileOutputStreamDemo {
  	public static void main(String[] args) throws Exception {
  		//1.创建源
  		File f = new File("C:/Users/15626/Desktop/test/123.txt");
  		//2.创建输出流对象
  		FileOutputStream out = new FileOutputStream(f);
  		//3.写操作
  		out.write(97);//只能一个一个的写
  		
  		//将buffer数组中的数据写在文件中
  		byte[] buffer = "ABCDEF".getBytes();
  		out.write(buffer);
  		
  		//从索引1开始的3个字节写在文件中
  		out.write(buffer, 1, 3);
  		
  		//4.关闭资源
  		out.close();
  	}
  }
  

• 文件字符输入流(FileReader)

  字符流的方法是从父类中继承过来的，也和上面字节流的方法大同小异

   int read()  读取单个字符。 
   int read(char[] cbuf, int offset, int length)  将字符读入数组中的某一部分。 
  

  //文件字符输入流
  public class FileReaderDemo {
  	public static void main(String[] args) throws IOException {
  		//1.创建源
  		File src = new File("C:/Users/15626/Desktop/新建文件夹 (2)/test.txt");
  		//2.创建字符输入流对象
  		FileReader in = new FileReader(src);
  		//3.读操作
  		char[] buffer = new char[10];
  		int len = -1;
  		while((len = in.read(buffer)) != -1){
  			String str = new String(buffer,0,len);
  			System.out.println(str);
  		}
  		//4.关闭流
  		in.close();	
  	}
  }
  

• 文件字符输出流(FileWriter)

  void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。          
  void write(int c)  写入单个字符。 
  void write(String str, int off, int len) 写入字符串的某一部分。 
  

文件的拷贝操作

把指定目录的.java文件拷贝到指定的目录

//拷贝文件：把指定目录的.java文件拷贝到指定的目录
public class FileCopyDemo2 {
	public static void main(String []args) throws Exception{
		//得到指定目录的文件
		File srcDir = new File("C:/Users/15626/Desktop/新建文件夹 (2)");
		File destDir = new File("C:/Users/15626/Desktop/新建文件夹 (2)/qqq");
		//筛选出后缀是.java的文件存储在fs这个文件数组中
		File[] fs = srcDir.listFiles(new FilenameFilter(){
			@Override
			public boolean accept(File dir, String name){
				return new File(dir,name).isFile() && name.endsWith(".java");
			}
		});
		//遍历这些文件
		for (File srcFile : fs) {
			//1.创建目标
			File destFile = new File(destDir,srcFile.getName());
			//2.创建输入流和输出流对象
			FileInputStream in = new FileInputStream(srcFile);
			FileOutputStream out = new FileOutputStream(destFile);
			//3.输入输出操作
			byte[] buffer = new byte[10];
			int len = -1;
			while((len = in.read(buffer)) != -1){
				out.write(buffer, 0, len);
			}
			//4.关闭流
			in.close();
			out.close();
		}
	}
}

文件夹的拷贝

https://www.cnblogs.com/tfper/p/9855228.html

文件流正确关闭资源

https://www.cnblogs.com/tfper/p/9833722.html

五、缓冲流

缓冲流是一个包装流,目的起缓冲作用.操作流的时候,习惯定义一个byte/char数组. int read():每次都从磁盘文件中读取一个字节. 直接操作磁盘文件性能极低，为了解决这个问题，我们 定义一个数组作为缓冲区. byte[] buffer = new byte[1024]; 该数组其实就是一个缓冲区. 一次性从磁盘文件中读取1024个字节. 如此以来,操作磁盘文件的次数少了，性能得以提升，java提供的默认缓存区大小是8192(1024*8),我们一般不用修改大小.

缓冲流也有四种，分别是 BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter.操作方法都和文件流差不多，我们来看一下缓冲流到底快了多少？

/**
 * @author 15626
 *	操作字符或者字节流都应该用缓冲流包装起来，现在比较一下用缓冲流和不用缓冲流的情况写，复制一个文件所花费时间
 *	长度的比较
 */
public class BufferCompare {
	public static void main(String[] args) throws Exception {
		File srcFile = new File("C:/Users/15626/Desktop/File/test.pdf");
		File destFile = new File("C:/Users/15626/Desktop/File/copy.pdf");
		//test1(srcFile,destFile);//不用缓冲流包装       
		test2(srcFile,destFile);//用缓冲流包装       
	}
	//使用缓冲流,从内存每次读取1024个字节：15ms
	public static void test2(File srcFile, File destFile) throws Exception {
		long begin = System.currentTimeMillis();
		BufferedInputStream in = new BufferedInputStream(new FileInputStream(srcFile));
		BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(destFile));
	
		byte[] buffer = new byte[1024];
		int len = -1;
		while((len = in.read(buffer)) != -1){
			out.write(buffer, 0, len);
		}
		in.close();
		out.close();
		System.out.print(System.currentTimeMillis() - begin);
	}

	//使用字节流，从磁盘中每次读取1024个字节：38ms
	public static void test1(File srcFile,File destFile) throws Exception {
		long begin = System.currentTimeMillis();
		FileInputStream in = new FileInputStream(srcFile);
		FileOutputStream out = new FileOutputStream(destFile);
		byte[] buffer = new byte[1024];
		int len = -1;
		while((len = in.read(buffer)) != -1){
			out.write(buffer, 0, len);
		}
		in.close();
		out.close();
		System.out.print(System.currentTimeMillis() - begin);
	}
}

缓冲流的效率很高，所有以后操作字符字节流都可以用缓冲流包装起来。

六、内存流

内存流就是把程序中的数据暂存在内存中，在这里也就是数组中，或者把内存中的数据输出到其他媒介，内存流也是分为字节流，字符流还有一个字符串流(保存在字符串中)。简单操作一下，熟悉一个方法

import java.io.*;
/**
 * @author 15626
 *	字节内存流,或者说是字节数组流
 *	字节内存输入流 ： ByteArrayOutputStream
 *	字节内存输出流 : ByteArrayInputStream
 */
public class ByteArrayStreamDemo {
	public static void main(String[] args) throws Exception {
		//字节内存输出流：把程序的内容写到内存中的byte数组中
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		out.write("ABSAK".getBytes());
		//把程序中的数据存在了缓冲数组中，toByteArray()方法用来获取缓冲区的数据
		byte[] buffer = out.toByteArray();
		
		//字节内存输入流: 把内存中的数据读到程序中
		ByteArrayInputStream in = new ByteArrayInputStream(buffer);
		byte[] by = new byte[1024];
		int len = -1;
		while((len = in.read(by)) != -1){
			System.out.print(new String(by,0,len));
		}
		
		//关闭流无效，因为本身就在存储在内存中
		in.close();
		out.close();
	}
}

/**
 * @author 15626
 *	字符内存流或者说是字符数组流
 *	字符内存输出流：CharArrayWriter
 *	字符内存输入流：CharArrayReader
 */
public class CharArrayReaderWriterDemo {
	public static void main(String[] args) throws Exception {
		//字符内存输出流 ： 从程序把数据存储到内存中的一个缓冲数组中
		CharArrayWriter cWriter = new CharArrayWriter();
		cWriter.write("你是天边最美的云彩");
		//获取缓冲数组中的内容,用toCharArray()方法获取
		char[] ch= cWriter.toCharArray();
		
		//字符内存输入流：从内存中被数据读取到程序中来
		CharArrayReader sReader = new CharArrayReader(ch);
		char[] buffer = new char[1024];
		int len = -1;
		while((len = sReader.read(buffer)) != -1){
			System.out.println(new String(buffer,0,len));
		}
		
		
		//关闭流无效，因为本身就在存储在内存中
		sReader.close();
		cWriter.close();
	}
}

/**
 * @author 15626
 *	字符串的内存流，把程序中的数据存储在一个缓冲字符串中
 *	字符串的输出流 ：StringWriter
 *	字符串的输入流：StringReader
 */
public class StringWriterReaderDemo {
	public static void main(String[] args) throws Exception {
		//字符串的输出流
		StringWriter out = new StringWriter();
		out.write("你真的想成为一只帅帅气气的一只小人吗");
		//获取缓冲区的字符串
		//System.out.print(out.toString());
		
		//字符串的输入流
		StringReader in = new StringReader("海纳百川，有容乃大");
		char[] buffer = new char[1024];
		int len = -1;
		while((len = in.read(buffer)) != -1){
			System.out.print(new String(buffer,0,len));
		}
		
		//关闭流无效，因为本身就在存储在内存中
		in.close();
		out.close();
	}
}

要注意的关闭流无效，但是为了追求完美的格式,防止忘记了其他流的关闭，我还还是自娱自乐的关一下吧！

七、对象流

对象流包括ObjectInputStream和ObjectOutputStream，名字起得很有范，肯定是字节流

一般用对象流进行序列化和反序列化通过writeObject方法做序列化操作的，通过readObject方法做反序列化操作

1.序列化

指把堆内存中的Java对象数据,通过某种方式把对象存储到磁盘文件中或者传递给其他网络的节点(在网络上传输). 我们把这个过程称之为序列化.

需要做序列化的对象的类,必须实现序列化接口:java.io.Serializable接口(标志接口[没有抽象方法]). 底层会判断,如果当前对象是Serializable的实例,才允许做序列化.大多数类都已经实现了这个接口了

2.反序列化

把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象的过程.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author 15626
 *	对象流的序列化和反序列化操作
 *	ObjectInputStream 用WriterObjcet 来做序列化
 *	ObjectOutputStream 用ReaderObject 来做反序列化
 *	需要做序列化的类必须实现Serializable接口 
 */
public class ObjectStreamDemo {
	public static void main(String[] args) throws Exception {
		File f = new File("file/111.txt");
		writeObject(f);//序列化
		readObject(f);//反序列化
	}
	public static void readObject(File f) throws Exception{
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
		Student s = (Student)in.readObject();
		System.out.println(s);
		in.close();
		
	} 
	public static void writeObject(File f) throws Exception {
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
		out.writeObject(new Student("小伙子",19,"12345"));
		out.close();
	}
}
class Student implements Serializable {
	/**
	 * 做反序列化操作必须存在序列化的字节码文件，由于随着版本升级肯定字节码会发生改变，java提供了序列化版本ID，
	 * 可以固定这一份字节码文件，解决了这个问题
	 */
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	//密码一般不会做序列化的，静态的字段和瞬态的字段不能做序列化，所以给密码加上瞬态transient修饰符
	//反序列化的结果就为null
	transient private String password;
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", password=" + password + "]";
	}
	public Student(String name, int age, String password) {
		super();
		this.name = name;
		this.age = age;
		this.password = password;
	}
}

可以看到里面有两个重要的问题，一个是反序列化对象需要对象的字节码文件，需要提供序列化ID固定这份字节码文件，还有一个是transient瞬息字段是不能序列化.

八、打印流

1.字节打印流

import java.io.File;
import java.io.PrintStream;

/**
 * @author 15626
 * 字节打印流
 *  可以自动刷新的，不想API说的那样，必须用换行符或者println才可以刷新缓冲区
 */
public class PrintStreamDemo {
	public static void main(String[] args) throws Exception {
		File f = new File("file/123.txt");
		PrintStream p = new PrintStream(f);
		p.print("aa");
		p.println(121);
		p.append("a");
		p.close();
		
//		System.out.println();  //这行代码等价于下面的两行代码
//		PrintStream ps = System.out;
//		ps.println("a");
	}
}

2.字符打印流

/**
 * @author 15626
 *	字符打印流
 *	当启用自动刷新后，即new PrintWriter(new FileOutputStream(f),true);   true
 *	调用println方法或者printf或者\n后进行刷新。
 *
 *	当不启动自动刷新，需要手动刷新，调用flush方法，或者close方法会进行刷新
 */
public class PrintWriterDemo {
	public static void main(String[]args) throws Exception{
		File f = new File("file/123.txt");
		PrintWriter p = new PrintWriter(new FileOutputStream(f),true);
		p.print("wqe");
		p.println();
		p.close();
	}
}