【我的Java笔记】I/O流

I / O流（输入/输出 流）

1.概述：I/O（Input/Output，输入/输出）流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。

2.输入/输出模式图解

3. I/O流的作用：设备和设备之间的数据传输（硬盘和内存之间）

4.IO流的分类：

（1）按流的流向分为：

①输入流：读数据

②输出流：写数据

（2）按数据类型分为：

①字节流（字节输入流：InputStream，字节输出流：OutputStream）

②字符流（字符输入流：Reader，字符输出流：Writer）

5.IO流上传和下载图解：

7.OutputStream类和IntputStream类都为抽象类

*注：输入流使用什么方式读取，输出流也应使用此种方式写入，保持一致！！！

（如使用基本字节输入流一次读取一个字节数组，则输出流在写入的时候也应用基本字节输出流写入！）

一、输入流

1.结构图

1.字节输入流（图片、音频、视频文件使用）

（1）基本字节输入流：FileInputStream

1.字节输入流读取数据的两种方式：

（1）一次读取一个字节（模版代码）：

int by = 0 ;

while((by=字节输入流对象.read())!=-1){//返回-1表示文件读取完毕

    System.out.print((char)by)

}

（2）一次读取一个字节数组（模版代码）：

byte[] bys =new byte[1024] ;//定义缓冲区大小，1024或者1024的倍数

int len = 0 ;//读取字节数的实际长度

while((len=字节输入流对象.read(bys))!=-1){

  System.out.println(new String(bys,0,len));   //从指定的索引开始 (0索引)，读取的为实际长度

} 

2.开发步骤：

（1）创建字节/字符输入流对象

（2）读取数据

（3）释放资源

3.FileInputStream构造方法：

public FileInputStream (String name)

4.读取数据的两种方式：

（1）public int read()一次读取一个字节

（2）public int read(byte[] b)一次读取一个字节数组（返回的是实际读取的字节数）

例1：（一次读取一个字节）

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputDemo1 {
	public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("fos.txt"); 
		
		int len = 0;
		while((len = fis.read())!=-1) {
			System.out.print((char)len);
		}
	}
}

例2：（一次读取一个字符数组）

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputDemo {
	public static void main(String[] args) throws IOException {

		FileInputStream fis = new FileInputStream("fos.txt");

		byte[] bys = new byte[1024];
		int len = 0;

		while ((len = fis.read(bys)) != -1) {
			System.out.println(new String(bys, 0, len));
		}
	}
}

5.IO流中文件复制粘贴的操作步骤（详见博客：《IO流_使用IO流进行文件的复制和粘贴》）：

1.数据源文件-------->输入流-------->读数据

2.目的地文件-------->输出流-------->写数据

（2）高效字节缓冲输入流：BufferedInputStream

注：字节缓冲流不能针对文件进行直接操作

缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件进行操作

1.构造方法：

BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象

2.字符输入流（文本文件使用）

（1）基本字符输入流：InputStreamReader-------->便捷类：FileReader

1.构造方法：

public InputStreamReader(InputStream in,charset sc)

注：字节输入流+编码格式（例：GBK，UTF-8）

2.方法：

（1）public int read()读取单个字符

（2）public int read(char[] ch)读取一个字符数组

（2）高效字符缓冲输入流：BufferedReader

1.构造方法：

BufferedReader(Reader in) 创建默认缓冲大小

2.特有方法：

（1）public String readLine()一次读取一行 （返回为String类型）

3.public String readLine():一次读取一行数据

模版代码：

String line = null ;

while((line=字符缓冲输入流对象.readLine())!=null){

  System.out.println(line) ;

}

例：使用BufferedReader中的readLine()方法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Test1 {
	public static void main(String[] args) throws IOException {
		// 创建输入流对象
		BufferedReader br = new BufferedReader(new FileReader("s.txt"));
		// 使用特有方法每次读取一行
		String str = null;
		while ((str = br.readLine()) != null) {
			System.out.println(str);
		}

		// 释放资源
		br.close();
	}
}

二、输出流

结构图

1.字节输出流

（1）基本字节输出流：FileOutputStream类（OutputStream的子类）

1.构造方法：

public FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流

文件中追加写入数据：public FileOutputStream(File file,boolean append):第二个参数设置为true,表示写入文件的末尾处

注：该方法本身会抛出异常：IOException

2.输出流中写数据的方法:
  （1）public abstract void write(int b)将指定的字节写入到输出流中
  （2）public void write(byte[] b)将指定的字节数组写入到输出流中
  （3）public void write(byte[] b, int off,int len)将字节数组的一部分写入到输出流中

3.换行符号：

Windows：\r\n

Linux：\n

Mac：\r

4.文本文件输出的开发步骤：

   1) 创建文件输出流对象
   2) 写数据
   3) 关闭资源

例：

/*
 * 输出一个文本文件，并在其中写一句话
 * */

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamDemo {
	public static void main(String[] args) throws IOException {
		// 1）创建输出流对象
		FileOutputStream fos = new FileOutputStream("fos.txt");

		// 2）使用String中的getBytes()方法转为字节 ;
		fos.write("im zilatan".getBytes());

		// 3）释放流资源 public void close()
		fos.close();
		/**
		 * 关闭流资源,关闭了就不能在写数据了 并且该流对象输出完毕之后,不指向这个文件了,所以需要将它关闭掉
		 */

	}
}

例2：write()方法的使用

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

public class FileOutputStreamDemo {
	public static void main(String[] args) {
		//创建一个文件输出流对象
		FileOutputStream fos1 = null;
		try {
			fos1 = new FileOutputStream("fos1.txt");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}

		//public void write(byte[] b):将指定的字节数组写入到输出流中
		byte[] bys = {97,98,99,100,101} ;
		try {
			fos1.write(bys) ;
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//public void write(byte[] b, int off,int len):实际开发中:该方法和读数据一块使用
		try {
			fos1.write(bys, 1, 3) ;
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//关闭资源
		try {
			fos1.close() ;
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

例3：换行符和文件末尾追加数据方法的使用

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo2 {
	
	public static void main(String[] args) throws IOException {
		
		//创建一个输出流对象
		FileOutputStream fos = new FileOutputStream("fos3.txt",true) ;
		
		//写数据
		for(int i = 0 ; i <10 ; i ++){
			fos.write(("hello"+i).getBytes()) ;
			//换行符号
			fos.write("\r\n".getBytes());
		}
		
		//关闭资源
		fos.close() ;
	}
}

例4：IO流中加入异常操作（try...catch()...finally...）

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

public class FileOutputStreamDemo3 {
	public static void main(String[] args) {
		// 声明一个变量
		FileOutputStream fos = null;

		try {
			fos = new FileOutputStream("fos4.txt");
			// 写数据
			fos.write("im zilatan!".getBytes());
			fos.write("im javier!".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 释放资源：由于是流对象,要对流对象做非空判断
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
}

（2）高效字节缓冲输出流：BufferedOutputStream

注：字节缓冲流不能针对文件进行直接操作

缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件进行操作

1.构造方式：

public BufferedOutputStream(OutputStream out): 默认缓冲区大小(默认缓冲大小已经足够大了)

2.字符输出流

（1）基本字符输出流：OutputStreamWriter------------>便捷类：FileWriter

1.构造方法：

public InputStreamReader(InputStream in,charset sc)

注：字节输入流+编码格式（例：GBK，UTF-8）

2.方法：

（1）public void flush()刷新该流的缓冲

（2）public void write()写入单个字符

（3）public void write(char[] ch)写入一个字符数组

（4）public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分

（5）public void write(String str)写入字符串

（6）public void write(String str, int off,int len)写字符串的一部分

注： flush()和close()方法的区别
  flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
    close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!

（2）高效字符缓冲输出流：BufferedWriter

1.构造方法：

public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流

2.特有方法：

public void newLine()写入一个换行符号

例：使用BufferedWriter中的特有方法newLine()

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Test1 {
	public static void main(String[] args) throws IOException {
		// 创建输出流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("s.txt"));

		bw.write("i am zilatan!");
		// 使用特有方法写入时进行分行
		bw.newLine();
		bw.write("i love inter!");

		// 刷新流
		bw.flush();

		// 释放资源
		bw.close();
	}
}