JAVA输入输出处理（IO流）【超详细，纯手撸代码】

输入输出处理（IO流）

文件处理

读取文件

source = "...."
    File file = new File(source);

在目标地址创建文件

file.creatNewFile();

常用方法

file.getName();//文件名
file.size(); //文件大小 utf-8 中，英文一个字节，中文三个字节
file.isFile() //是否是文件
    file.isDirectory()    //是否是目录
    file.exists()    //是否存在
    file.mkdirs()   //创建多级目录
    file.mkdir()   //创建目录

Java流的分类

流分类	使用分类	字节输入流	字节输出流	字符输入流	字符输出流
	抽象基类	InputStream	OutputStream	Reader	Writer
处理流	访问文件	FileInputStream	FileOutStream	FileReader	FileWriter
处理流	访问数值	ByteArrayInputStream	ByteArrayOutStream	CharArrayReader	CharArrayWriter
处理流	访问管道	PipedInputStream	PipedOutStream	PipedReader	PipedWriter
处理流	访问字符串			StringReader	StringWriter
包装流	缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
包装流	转换流			InputStreamReader	OutputStreamWriter
包装流	对象流	ObjectInputStream	ObjectOutputStream
包装流	抽象基类（过滤）	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
包装流	打印流		PrintStream		PrintWriter

IO流抽象基类

字节输入流：InputStream
字节输出流：OutputStream
字符输入流：Reader
字符输出流：Writer 

FileInputStream （InputStream的子类）

创建一个FileInputStream 与file关联起来

FileInputStream fileInputStream = new FileInputStream(file);   //文件
FileInputStream fileInputStream = new FileInputStream(String name);   //路径
int read = 0;
while((read = fileInputStream.read()) != -1){
    System.out.print((char)read);
}    //中文一个字是三个字节，read一次只能读取一个字节，会乱码
//单个字节读取，效率低
//read 读取正常，返回实际读取的字节数，否则返回-1
​
Byte byte =new Byte[8];
int readLen = 0;
while((readLen = fileInputStream.read(byte)) != -1){
    System.out.print(new String(byte,0,readLen));
} 
//new String(byte,0,readLen)  byte数组中0-readLen长度的元素
//读取一个字节数组
//readLen 返回读取实际的字节数，否则返回-1

FileOutputStream （0utputStream的子类）

FileOutputStream fileOutputStream = new FileOutputStream(file);   //写文件时会覆盖原来的文件
FileOutputStream fileOutputStream = new FileOutputStream(file，true);   //写文件时会在原来的文件的末尾添加
fileOutputStream.write();  //写入单个字节
String s = ".....";
fileOutputStream.write(s.getByte());    //s.getBytes()   将字符串转化为字字节 数组
//写入一个字符串
fileOutputStream.write(s.getByte()，0，3);    //s.getBytes()   将字符串转化为字节数组，写入从下标0到下标3的数据

字符流读取

FileReader (InputStreamReader的子类，InputStreamReader的父类是Reader)

FileReader fileReader = new FileReader(file);   //将一个文件转化为字符流输入对象

字符流输出

FileWriter(outputStreamWriter的子类，outputStreamWriter的父类是Writer)

FileWriter fileWriter = new FileWriter(file);   //将一个文件转化为字符流输出对象
FileWriter fileWriter = new FileWriter(file，true);   //写入的时候会在后面添加，而不是覆盖
FileOutputStream fileOutputStream = new FileOutputStream(file);   //写文件时会覆盖原来的文件
FileOutputStream fileOutputStream = new FileOutputStream(file，true);   //写文件时会在原来的文件的末尾添加
fileOutputStream.write();  //写入单个字符
String s = ".....";
fileOutputStream.write(s.toCharArray());    //s.toCharArray()   将字符串转化为字符数组
//写入一个字符串
fileOutputStream.write(s.toCharArray()，0，3);    //s.toCharArray()   将字符串转化为字符数组，写入从下标0到下标3的数据
fileOutputStream.write("....")  //写入一个字符串
fileOutputStream.write(....,0,3) //写入这个字符串从下标0到下标3的元素

• 节点流：对某一个特定的数据源进行读写数据 如 FileInputStream FileOutputStream FileReader FileWriter

灵活，效率会受影响，功能不强大

• 包装流：对节点流进行包装，让功能更强大

包装流

BufferdReader

属性包含 reader 可以对Reader的子类进行包装

BufferdReader bufferdReader = new BufferdReader(new FileReader(file));
String line;
while((line =bufferdReader.readLine)!=null ){
    System.out.print(line);
}                       //bufferdReader.readLine    返回读的内容，如果读不到返回null 不读换行符
    bufferdReader.close();     //只用关闭外层流就可以，bufferdReader.close()方法里面有关闭节点流的方法
                                //关外自动关内

BufferdWriter

属性包含 Writer可以对Writer的子类进行包装

BufferdWriter bufferdWriter = new BufferdWriter(new FileWriter(file));
BufferdWriter bufferdWriter = new BufferdWriter(new FileWriter(file，true));  //追加内容，不会覆盖
bufferdWriter.newLine();    //根据当前的系统自动生成一个换行符
}                       
    bufferdWriter.close();     //只用关闭外层流就可以，bufferdReader.close()方法里面有关闭节点流的方法
                                //关外自动关内

ObjectInputStream 完成数据的序列化 （保存值和数据类型）

• 包装流 可以对可以对InputStream的子类进行包装

• 序列化的对象要实现Serializable接口

• 序列化后保存的文件格式不是纯文本的，是按照他的格式来保存的

• transient , static修饰的属性和方法不会被序列化

• 序列化对象时，它的属性也一定要实现Serializable，比如一个其他类作为的的属性，那这个类也要实现Serializable

• 序列化是可继承的，父类实现序列化（实现Serializable接口），子类默认就可以实现序列化

ObjectOutputStream 完成数据的反序列化

反序列化的顺序需要和序列化的顺序保持一致，否则会出现异常

InputStreamReader

包装流 将字节流转换为字符流 对 InputSatream的子类进行包装

InputStreamReader inputStreamReader = new InputStreamReader(InputStream); //默认编码转换。utf-8
InputStreamReader inputStreamReader = new InputStreamReader(InputStream，Charset);//指定编码转换,将这种编码的内容转换为标准的内容
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file),"utf-8");
BufferdReader bufferdReader = new BufferdReader(inputStreamReader);
bufferdReader.readLine();
.....

OutputStreamWriter

包装流 将字节流转换为字符流 对 InputSatream的子类进行包装

OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream); //默认编码转换。utf-8
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream，Charset);//指定编码转换,将内容转换为你指定的编码格式的内容
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file),"utf-8");
BufferdWriter bufferdWriter = new BufferdWriter(inputStreamWriter);
String s = "1234"
bufferdWriter.writer(s);     //将s以utf-8的编码格式写入文件里
.....

打印流 (包装流)

只有输出流，没有输入流

字节打印流：PrintStream

PrintStream printStream = new PrintStream(file);
PrintStream printStream = new PrintStream(OutputStream);


PrintStream out = System.out;
out.print("1234");            //默认情况下PrintStream 输出数据的位置是 标准输出 ，即显示器
//因为print底层用的还是writer（），所以也可以直接调用writer（）方法打印
out.write("1234".getBytes());
out.close();
//可以改变打印流输出的位置
System.setOut(new PrintStream(file));
    System.out.print("....");  //向source地址的文件输出

字符打印流：PrintWriter

Printer printer = new Printer(System.out);   
printer.print();   //标准输出 到控制台
Printer printer = new Printer(new FileWriter(source));
printer.print();             //输出到source目标地址
printer.close();          // flush+关闭流 close（）之后才会写入数据