Java之IO流详解

IO流

1.概述

IO流用于处理设备之间的数据传输，Java对数据的操作是通过流的方式。
流按流向分为两种：输入流和输出流。
流按操作类型分为两种：

字节流：字节流可以操作任何数据，因为在计算机中任何数据都是以字节的形式存储的
字符流：字符流只能操作纯字符数据，比较方便。

2.字节流

2.1.FileInputStream

FileInputStream fileInputStream=new FileInputStream("www.txt");
		int i;
		while ((i = fileInputStream.read()) != -1) {
    
    
			System.out.println(i);
		}
		fileInputStream.close();

read()方法读取的是一个字节,为什么返回是int,而不是byte
因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是以二进制形式的存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111，那么这11111111是byte类型的-1,我们的程序是遇到-1就会停止不读了,后面的数据就读不到了,所以在读取的时候用int类型接收,如果11111111会在其前面补上24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完,而结束标记的-1就是int类型

2.2.FileOutputStream

		FileInputStream fileInputStream=new FileInputStream("www.txt");
		FileOutputStream fileOutputStream=new FileOutputStream("www.txt");
		int i=fileInputStream.read();
		System.out.println(i);

输出：
在这里插入图片描述

		FileOutputStream fileOutputStream=new FileOutputStream("www.txt");
		fileOutputStream.write(97);
		fileOutputStream.write(98);
		fileOutputStream.close();

	    FileOutputStream fileOutputStream=new FileOutputStream("www.txt",true);
		fileOutputStream.write(97);
		fileOutputStream.write(98);
		fileOutputStream.close();

注：FileOutputStream创建时如果没有www.txt，则自动创建一个；如果有www.txt不会创建，但是会清空www.txt。如果想要在www.txt里面追加内容则需要FileOutputStream(“www.txt”，true)；
拷贝图片

第一种方法：

		FileInputStream fis=new FileInputStream("test.jpg");
		FileOutputStream fos=new FileOutputStream("copy.jpg");
		int a;
		while((a=fis.read())!=-1){
    
    
			fos.write(a);
		}
		fis.close();
		fos.close();

在这里插入图片描述
这种方法是一个字节一个字节读取和写入，速度太慢
2. 第二种方法

		FileInputStream fis=new FileInputStream("test.jpg");
		FileOutputStream fos=new FileOutputStream("copy.jpg");
		byte[] a=new byte[fis.available()];
		fis.read(a);
		fos.write(a);
		fis.close();
		fos.close();

在这里插入图片描述
这种方法是将所拷贝的内容全部放入到一个数组中，然后再讲数组中的内容写入到所拷贝的文件中，这种方法也不建议使用，因为有可能导致内存溢出。

第三种（定义小数组）

		 FileInputStream fis=new FileInputStream("www.txt");
		FileOutputStream fos=new FileOutputStream("copy.txt");
		int len;
		byte[] a=new byte[2];//舒张压的标准格式为1024的整数倍，这里的2是因为原文件的长度为太短
		while ((len=fis.read(a))!=-1) {
    
    
			fos.write(a, 0, len);
		}
		fis.close();
		fos.close();

将数组定义为1024的整数倍，便于操作，建议使用这种方法。

2.3.BufferedInputStream和BufferOutputStream拷贝

缓冲思想：字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想，所以提供了字节缓冲区流
BufferedInputStream：BufferedInputStream内置了一个缓冲区(数组)，从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个，程序再次读取时, 就不用找文件了, 直接从缓冲区中获取，直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
BufferedOutputStream：BufferedOutputStream也内置了一个缓冲区(数组)，程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中，直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。

		FileInputStream fis=new FileInputStream("www.txt");
		FileOutputStream fos=new FileOutputStream("copy.txt");
		BufferedInputStream bis=new BufferedInputStream(fis);	//创建缓冲区对fis装饰
		BufferedOutputStream bos=new BufferedOutputStream(fos); //创建缓冲区对fos修饰
		int len;
		while((len=bis.read())!=-1){
    
    
			bos.write(len);
		}
		bis.close();
		bos.close();

小数组的读写和带Buffer的相比较：
如果定义的小数组的大小是8192个字节，和Buffer相比较，小数组要比Buffer快，因为小数组读和写操作的是同一个数组，而Buffer操作的是两个数组。
flush和close方法的区别

flush()方法：用来刷新缓冲区的,刷新后可以再次写出
close()方法：用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

2.4.字节流读写中文

读：

		FileInputStream fis=new FileInputStream("www.txt");
		byte[] arr=new byte[2];
		int len;
		while((len=fis.read(arr))!=-1){
    
    
			System.out.println(new String(arr,0,len));
		}
		fis.close();
		//字节流在读中文的时候有可能会读到半个中文,造成乱码 ，比如有符号，或者其他符号时，中文是两个字节，而符号是一个字节，就有可能乱码。

写：

		FileOutputStream fos=new FileOutputStream("copy.txt");
		fos.write("程序汪熬夜撸代码".getBytes());
		fos.close();
		//字节流直接操作的字节,所以写出中文必须将字符串转换成字节数组

2.5.图片加密

将写出的字节异或上一个数，这个数就是密钥，解密的时候再次异或就可以了。

扫描二维码关注公众号，回复： 12678648 查看本文章

FileInputStream fis=new FileInputStream("test.jpg");
		FileOutputStream fos=new FileOutputStream("copy.jpg");
		int a;
		while((a=fis.read())!=-1){
    
    
			fos.write(a^123);
		}
		fis.close();
		fos.close();

3.字符流

概述：字符流是可以直接读写字符的IO流，字符流要读取字符，要先读取字节数据，然后将字节数据转换成字符；如果要写出字符，需要把字符转换成字节再写出。

3.1FileReader和FileWriter

FileReader

	public static void main(String[] args) throws IOException {
    
    
		FileReader fr=new FileReader("www.txt");
		int len;
		while((len=fr.read())!=-1){
    
    
			System.out.println((char)len);
		}
		fr.close();
	}

FileWriter

public static void main(String[] args) throws IOException {
    
    
		FileWriter fw=new FileWriter("www.txt");
		fw.write("程序汪熬夜撸代码");
		fw.close();
	}

3.2字符流的拷贝

第一种方法：

		FileReader fr=new FileReader("www.txt");
		FileWriter fw=new FileWriter("copy.txt");
		int len;
		while((len=fr.read())!=-1){
    
    
			fw.write(len);
		}
		fr.close();
		fw.close();
		//注：FileWriter的底层是缓冲区来实现的。

字符流的使用情况：字符流也可以拷贝文件，但不推荐使用，因为字符流拷贝文件需要经历字节->字符和字符->字节双向转换，即读取的时候要将字节转换成字符，写入的时候要将字符转换成字节。所以只在读取一段文本或者写入一段文本的时候才使用字符流。
字符流不可以拷贝非纯文本的文件，因为在读的时候会把字节转换成字符，在转换过程中可能找不到对应的字符，就会用？代替，写出的时候会将字符转换成字节写出去，如果是？，则直接写出，这样拷贝的文件就出现了乱码。
第二种方法：（自定义小数组）

		FileReader fr=new FileReader("www.txt");
		FileWriter fw=new FileWriter("copy.txt");
		int len;
		char[] arr=new char[1024];
		while((len=fr.read(arr))!=-1){
    
    
			fw.write(arr,0,len);
		}
		fr.close();
		fw.close();

第三种方法：（缓冲区）
①

BufferedReader br=new BufferedReader(new FileReader("www.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("copy.txt"));
		int len;
		while((len=br.read())!=-1){
    
    
			bw.write(len);
		}
		br.close();
		bw.close();

②readLine()和newLine()方法
注：

BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)
BufferedWriter的newLine()可以输出一个跨平台的换行符号"\r\n"

BufferedReader br=new BufferedReader(new FileReader("www.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("copy.txt"));
		String lenString;
		while((lenString=br.readLine())!=null){
    
    
			bw.write(lenString);
			bw.newLine();
		}
		br.close();
		bw.close();

newline()方法支持跨平台，而"\r\n"只支持windows系统。

3.3LineNumberReader

概述：
LineNumberReader是BufferedReader的子类, 具有相同的功能, 并且可以统计行号

调用getLineNumber()方法可以获取当前行号
调用setLineNumber()方法可以设置当前行号

LineNumberReader lnr=new LineNumberReader(new FileReader("www.txt"));
		String lenString;
		lnr.setLineNumber(5);
		while((lenString=lnr.readLine())!=null){
    
    
			System.out.println(lnr.getLineNumber()+lenString);
		}
		lnr.close();

4.其他流

4.1序列流

概述：序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.

4.1.1序列流整合两个

	FileInputStream fis1=new FileInputStream("www.txt");
	FileInputStream fis2=new FileInputStream("com.txt");
	SequenceInputStream sis=new SequenceInputStream(fis1, fis2);//将两个流整合成一个流
	FileOutputStream foStream=new FileOutputStream("copy.txt");
	int len;
	while((len=sis.read())!=-1){
    
    
		foStream.write(len);
	}
	sis.close();
	foStream.close();

4.1.2序列流整合多个

		FileInputStream fis1=new FileInputStream("www.txt");
		FileInputStream fis2=new FileInputStream("com.txt");
		FileInputStream fis3=new FileInputStream("net.txt");
		FileOutputStream fos=new FileOutputStream("copy.txt");
		Vector<InputStream> v=new Vector<>();
		v.add(fis1);
		v.add(fis2);
		v.add(fis3);
		
		Enumeration<InputStream> e=v.elements();
		SequenceInputStream sis=new SequenceInputStream(e);
		int len;
		while((len=sis.read())!=-1){
    
    
			fos.write(len);
		}
		sis.close();
		fos.close();

4.2内存输出流

概述：该输出流可以向内存写数据，把内存当做一个缓冲区，写出之后可以一次性的获取出所有的数据

		FileInputStream fis=new FileInputStream("net.txt");
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		int len;
		while((len=fis.read())!=-1){
    
    
			baos.write(len);
		}
		System.out.println(baos);
		fis.close();

4.3随机访问流

概述：RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能；支持对随机访问文件的读取和写入。
构造方法：

RandomAccessFile(File file, String mode)
创建一个随机访问文件流从File参数指定的文件中读取，并可选地写入文件。
RandomAccessFile(String name, String mode)
创建随机访问文件流，以从中指定名称的文件读取，并可选择写入文件。
mode参数：可读：“r” ，可读写：“rw”，“rws”，或 “rwd”

4.4对象操作流

概述：该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

		Student s1=new Student("张三", 23, 33,43);
		Student s2=new Student("李四", 24, 34,44);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("net.txt"));
		oos.writeObject(s1);
		oos.writeObject(s2);
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("net.txt"));
		Student s3=(Student)ois.readObject();
		Student s4=(Student)ois.readObject();
		System.out.println(s3);
		System.out.println(s4);
		oos.close();
		ois.close();

在这里插入图片描述
优化：

		Student s1=new Student("张三", 23, 33,43);
		Student s2=new Student("李四", 24, 34,44);
		Student s3=new Student("小六子", 34, 54,94);
		Student s4=new Student("小马", 0, 54,64);
		ArrayList<Student> al=new ArrayList<Student>();
		al.add(s1);
		al.add(s2);
		al.add(s3);
		al.add(s4);
		
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("net.txt"));
		oos.writeObject(al);
		oos.close();
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("net.txt"));
		ArrayList<Student> oisList=(ArrayList<Student>) ois.readObject();
		for (Student student : oisList) {
    
    
			System.out.println(student);
		}
		ois.close();

在这里插入图片描述

4.5数据输入输出流

概述：DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据；例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.

		DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
		dos.writeInt(997);
		dos.writeInt(998);
		dos.writeInt(999);	
		dos.close();
		DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
		int x = dis.readInt();
		int y = dis.readInt();
		int z = dis.readInt();
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
		dis.close();

4.6打印流

概述：该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式。System.out就是一个PrintStream, 其默认向控制台输出信息
里面含有一个自动刷出的方法，不过用处不大。

		PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
		pw.write(97);
		pw.print("大家好");
		pw.println("你好");				//自动刷出,只针对的是println方法
		pw.close();

4.7标准输入输出流

概述:

System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据

System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据

修改输入输出流：

		System.setIn(new FileInputStream("a.txt"));				//修改标准输入流
		System.setOut(new PrintStream("b.txt"));				//修改标准输出流
			
		InputStream in = System.in;								//获取标准输入流
		PrintStream ps = System.out;							//获取标准输出流
		int b;
		while((b = in.read()) != -1) {
    
    							//从a.txt上读取数据
			ps.write(b);										//将数据写到b.txt上
		}
			
		in.close();
		ps.close();

IO流