IO，即in和out，也就是输入和输出，指应用程序和外部设备之间的数据传递，常见的外部设备包括文件、管道、网络连接。
Java 中是通过流处理IO 的，那么什么是流？
流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。
当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
1 流Stream在学习IO流之前,我们首先需要学习的概念就是Stream流
为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
1.流只能单方向流动
2.输入流用来读取 → in
3.输出流用来写出 → out
4.数据只能从头到尾顺序的读写一次
所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件
再结合对应类型的输入和输出方向,常用的流有:
File 字节流:针对二进制文件 InputStream FileInputStream BufferedInputStream ObjectInputStream OutputStream FileOutputStream BufferedOutputStream ObjectOutputStream 字符流:针对文本文件 Reader FileReader BufferedReader InputStreamReader Writer FileWriter BufferedWriter OutputStreamWriter PrintWriter一行行写出流的分类： 1.按照方向分类：输入流，输出流 2.按照操作的单位分类：字节流，字符流
组合情况： 字节输入流，字节输出流，字符输入流，字符输出流
字节输入流
抽象父级：InputStream—不能实例化
普通子级：
FileInputStream–操作文件的字符输入流
构造方法参数：File file / String pathname
package cn.tedu.file;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import static java.lang.System.in;
public class TestIn {
public static void main(String[] args) {
mtthod();//字节流的读取
}
//方法用于字节流的读取
private static void mtthod() {
InputStream in = null;
//创建流对象，注意InputStream是抽象父类，不可以实例化
try {
in = new FileInputStream("G:\学习\java\ready\123.txt");
//2.使用流对象，读取指定文件中的数据
// System.out.println(in.read());//97
// System.out.println(in.read());//98
// System.out.println(in.read());//99
// System.out.println(in.read());//-1
// System.out.println(in.read());//-1
// System.out.println(in.read());//-1
//优化代码，使用循环读取文件
int b;
//循环读取数据，只要读到的数据不等于-1，说明还有数据，符合循环条件，继续循环
while ((b = in.read()) != -1) {
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();//默认写法，打印错误信息
}finally {
//3.释放资源，流资源用完必须释放
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
BufferedInputStream–高效字节输入流
构造方法参数：InputStream，但无法创建抽象父级对象，所以传的是FileInputStream
package cn.tedu.review;
import org.omg.CORBA_2_3.portable.InputStream;
import java.io.*;
public class TestFile2 {
public static void main(String[] args) {
method(); //高效字符流读取
}
private static void method() {
java.io.InputStream in = null;
//1.创建流对象
// InputStream in2 = new BufferedInputStream(
// new FileInputStream(new File("G:\学习\java\ready\123.txt")));
try {
in = new BufferedInputStream(new FileInputStream("G:\学习\java\ready\123.txt"));
int a;
while ((a = in.read())!=-1){
System.out.println(a);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字节输出流
抽象父级：OutputStream—不能实例化
普通子级：
FileOutputStream–操作文件的字符输出流
构造方法参数：File file / String pathname
注意：默认存在一个参数Boolean append，默认值为false，覆盖输出，如果设置为true，追加输出
BufferedOutputStream–高效字节输出流
构造方法参数：OutputStream，但无法创建抽象父级对象，所以传的是FileOutputStream
package cn.tedu.file;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestOut {
public static void main(String[] args) {
//method1();//用来测试普通字节输出流
method2();//用来测试高效字节输出流
}
//本方法用于测试普通字节输出流FileOutputStream
private static void method1() {
FileOutputStream fileOutputStream = null;
try {
//1.创建流对象
//fileOutputStream = new FileOutputStream("G:\学习\java\ready\123.txt");
fileOutputStream = new FileOutputStream("G:\学习\java\ready\123.txt",true);
fileOutputStream.write(97);
fileOutputStream.write(98);
fileOutputStream.write(99);
fileOutputStream.write(45);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试高效字节输出流BufferedOutputStream
private static void method2() {
BufferedOutputStream bufferedOutputStream = null;
try {
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("G:\学习\java\ready\123.txt",true));
bufferedOutputStream.write(94);
bufferedOutputStream.write(94);
bufferedOutputStream.write(94);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符输入流
抽象父级：Reader—不能实例化
普通子级：
FileReader–操作文件的字符输入流
构造方法参数：File file / String pathname
BufferedReader–高效字节输入流
构造方法参数：Reader，但无法创建抽象父级对象，所以传的是FileReader
package cn.tedu.review;
import java.io.*;
public class TestIn {
public static void main(String[] args) {
//method1(); //用于测试普通的字符输入流
method2(); //用于测试高效字符输入流
}
//本方法用于测试高效字符输入流的读取操作
private static void method2() {
BufferedReader bufferedReader = null;
1.创建高效字符输入流对象
try {
bufferedReader = new BufferedReader(
new FileReader("G:\学习\java\ready\123.txt"));
int a;
while ((a=bufferedReader.read())!=-1){
System.out.println(a);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试普通字符输入流的读取操作
private static void method1() {
FileReader fileReader = null;
try {
//1.创建流对象
fileReader = new FileReader("G:\学习\java\ready\123.txt");
//2.使用流对象
int b;//定义变量用于保存读到的数据
while ((b=fileReader.read())!=-1){ //只要读到的数据不是-1，就继续循环
System.out.println(b);//打印读到的数据
}
} catch ( Exception e) {
e.printStackTrace();
}finally {
try {
//3.关流
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符输出流
抽象父级：Writer—不能实例化
普通子级：
FIleWriter–操作文件的字符输出流
构造方法参数：File file / String pathname
注意：默认存在一个参数Boolean append，默认值为false，覆盖输出，如果设置为true，追加输出
BufferedWriter–高效字节输出流
构造方法参数：Writer，但无法创建抽象父级对象，所以传的是FIleWriter
注意：默认存在一个参数Boolean append，默认值为false，覆盖输出，如果设置为true，追加输出
package cn.tedu.file;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class TestOut2 {
public static void main(String[] args) {
//method1();//用来测试普通字符输出流
method2();//用来测试高效字符输出流
}
//本方法用于测试普通字符输出流--FileWriter
private static void method1() {
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter("G:\学习\java\ready\123.txt",true);
fileWriter.write(95);
fileWriter.write(95);
fileWriter.write(95);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试普通字符输出流--BufferedWriter
private static void method2() {
BufferedWriter bufferedWriter = null;
try {
bufferedWriter = new BufferedWriter(new FileWriter("G:\学习\java\ready\123.txt",true));
bufferedWriter.write(28);
bufferedWriter.write(28);
bufferedWriter.write(28);
bufferedWriter.write(99);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
bufferedWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
