IO流的分类？
有多种分类方式：
一种方式是按照流的方向进行分类：
以内存作为参照物，
往内存中去，叫做输入（input）。或者叫做读（Read）。
从内存中出来，叫做输出（Output）。或者叫做写（Write）。
另一种方式是按照读取数据方式不同进行分类：
有的流是按照字节的方式读取数据，依次读取1个字节byte，等同于一次读取8个二进制位。
这种流是万能的，什么类型的文件都可以读取。包括：文本文件、图片、声音视频等。
假设文件file.txt，采用字节流的话是这样读的：
a中国bc
第一次读：一个字节，正好读到'a'
第二次读：一个字节，正好读到'中'字符的一半。
第三次读：一个字节，正好读到'中'字符的另外一半。
有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本
文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯文本文件，连word
文件都无法读取。
假设文件file.txt，采用字符的方式的话是这样读的：
a中国bc
第一次读：'a'字符('a'字符在Windows中占用1个字节)
第二次读：'中'字符（'中'字符在Windows中占用2个字节）
综上所述：流的分类
输入流、输出流
字节流、字符流
Java中的IO流都已经写好了，我们不需要关心。
注意：IDEA默认的当前路径在哪里？工程Project的根就是IDEA的默认当前路径
Java IO流这块有四大家族：
java.io.InputStream 字节输入流
java.io.OutputStream 自字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。
所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush()方法。
养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。
这个刷新表示将通道/管道当中剩余未输出的数据强行输出玩（清空管道！）刷新的作用就是清空管道。注意：如果没有flush()可能会导致丢失数据。
注意：在Java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。
java.io包下需要掌握的流有16个：
文件专属：
java.io.FileInputStream (掌握)
java.io.FileOutputStream （掌握）
java.io.FileReader
java.io.FileWriter
转换流：（将字节流转换成字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter
缓冲流专属：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream
数据流专属：
java.io.DataInputStream
java.io.DataOutputStream
标准输出流：
java.io.PrintWriter （掌握）
java.io.PrintStream
对象专属流：
java.io.ObjectInputStream （掌握）
java.io.ObjectOutputStream （掌握案例1
缺点：一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费在交互上面了。
package com.superman.readertest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Readtest {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\test.txt");
// while (true){
// int readData = fis.read();
// if (readData == -1){
// break;
// }
// System.out.println(readData);
// }
//改造while循环
int readData = 0;
while((readData = fis.read()) != -1){
System.out.println(readData);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}案例2 循环读取
package com.superman.readertest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest02 {
//一次最多读取ｂ．ｌｅｎｇｔｈ个字节
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis =new FileInputStream("C:\test.txt");
byte[] bytes = new byte[4];
// while (true){
// int readCount = fis.read(bytes);
// if (readCount == -1){
// break;
// }
// System.out.println(new String(bytes,0,readCount));
// }
int readCount = 0;
while((readCount =fis.read(bytes)) != -1){
System.out.println(new String(bytes,0,readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}案例3 这种方式不适合大文件，因为byte[]数组不能太大
package com.superman.readertest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest02 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("C:\test.txt");
System.out.println("总字节数" + fis.available());
byte[] bytes = new byte[fis.available()];
int readCount = fis.read(bytes);
System.out.println(new String(bytes));
} catch (IOException e) {
e.printStackTrace();
}
}
}以追加的方式在文件末尾写入，不会清空源文件内容
package com.superman.readertest;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("C:\test.txt",true);
byte[] bytes = {97,98,99,100};
fos.write(bytes);
String s = "我是一个中国人";
byte[] bs = s.getBytes();
fos.write(bs);
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}文件复制
案例代码
package com.superman.readertest;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("D:\test.avi");
fos = new FileOutputStream("C:\test.avi");
byte[] bytes =new byte[1024 * 1024];
int readCount = 0;
while((readCount = fis.read(bytes)) != -1){}
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}BufferedReader：
带有缓冲区的字符输入流。
使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。
代码示例（读的时候不带换行符）
package com.superman.readertest;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class BufferReaderTest {
public static void main(String[] args) throws IOException {
FileReader reader = null;
try {
reader = new FileReader("C:\test.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
BufferedReader br = new BufferedReader(reader);
String s =null;
while ((s = br.readLine()) != null){
System.out.println(s);
}
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}数据专属流
java.io.DataOutputStream : 数据专属的流，数据字节输出流。
这个流可以将数据连同数据的类型一并写入文件。注意：这个文件不是普通的文本文档（这个文件记事本打不开）
package com.superman.readertest;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamTest1 {
public static void main(String[] args) {
try {
//创建数据专属的字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data"));
// 写数据
byte b = 100;
short s = 200;
int i = 300;
long l = 400L;
float f = 3.0F;
double d = 3.14;
boolean sex = false;
char c = 'a';
//写
dos.writeByte(b);
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(l);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(sex);
dos.writeChar(c);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
java.io.DataInputStream： 数据字节输入流
DataOutputStream写的文件，只能使用DataInputStream去读。并且读的时候你需要提前知道写入的顺序。读的顺序需要和写的顺序一致。才可以正常取出数据。
package com.superman.readertest;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class DataInputStreamTest1 {
public static void main(String[] args) {
try {
DataInputStream dis = new DataInputStream(new FileInputStream("data"));
//开始读
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
boolean sex = dis.readBoolean();
char c = dis.readChar();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(sex);
System.out.println(c);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}标准输出流
java.io.PrintStream：标准的字节输出流。默认输出到控制台。
关于序列化和反序列化
objectOutputStream负责序列化，ObjectInputStream负责反序列化
1、参与序列化和反序列化的对象，必须实现Serializable接口
2、如果不想要某个字段参与序列化操作，使用transient关键字，表示游离的，不参与序列化。
