IO流

字节流：所有类型文件

字符流：纯文本文件

字节流

InputStream

FileInputStream

 FileInputStream fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\javase\\a.txt");

        int b;
        while((b=fis.read())!=-1){
            System.out.println((char)b);
        }

	fis.close();

1. 创建字节输入流对象

​ 如果文件不存在，就直接报错。

2. 读数据

​ read（）一次读一个字节数据，读出来的是ASCII数字。

​ read(byte[] b) 一次读一个字节数组数据

​ read() 读取一次数据移动一次指针

​ 读到末尾read方法返回-1

3. 释放资源

OutputStream

字节输出流

FileOutputStream

FileOutputStream fos=new FileOutputStream("C:\\a.txt",true);//创建字节输出流对象  默认为true,为false则会清空内容
        fos.write(91);//写数据
        fos.close();//释放资源

1. 创建字节输出流对象。

   文件不存在会创造新的文件，必须父级路径正确。

   如果文件已经存在，会清空数据。如果不想清空打开续写开关。

2. 写数据。

​ write(int b) 一字节

​ write(byte[]b)一数组

​ write(byte[]b,int off,int len) 一数组的部分

​ str.getBytes();字符串转换为byte[]

3. 释放资源。

换行 \r\n

拷贝

FileInputStream fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\javase\\a.txt");
FileOutputStream fos=new FileOutputStream("com\\copy.txt");
int b;
while((b=fis.read())!=-1){
    fos.write(b);
}
fos.close();
fis.close();

捕获异常

ctrl alt T。一般异常抛出

FileInputStream fis = null;//进行初始化
FileOutputStream fos = null;
try {
    fis = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\javase\\a.txt");
    fos = new FileOutputStream("com\\copy.txt");
    int b;
    while ((b = fis.read()) != -1) {
        fos.write(b);
    }

} catch (IOException e) {
    throw new RuntimeException(e);
} 

Unicode

UTF-8是一种编码规则。

英文按照1字节表示字母，中文按照3字节表示汉字。

缓冲流

BufferedInputStream

BufferedOutputStream

自带8192的缓冲区，基本流包装成高级流，提高读取数据的性能。

BufferedInputStream bis=new BufferedInputStream(new FileInputStream("C:\\Users\\Lenovo\\Desktop\\javase\\a.txt"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("C:\\Users\\Lenovo\\Desktop\\javase\\b.txt"));
int b;
while((b=bis.read())!=-1){
    bos.write(b);
}
bos.close();
bis.close();

byte[] bytes = new byte[1024];
int len;
while((len=bis.read(bytes))!=-1){
    bos.write(bytes,0,len);
}
bos.close();
bis.close();

序列化流

序列化流

ObjectOutputStream，对象操作输出流

把对象序列化到文件中去

ObjectInputStream（OutputStream out）//把基本流变为高级流
writerObject(Object obj)		//把对象序列化到文件中去

    Student stu=new Student("quqi",21);
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(""));
        oos.writeObject(stu);
        oos.close();

但需要在student类中implements序列化接口，该接口没有抽象方法，是标记接口

反序列化流

ObjectInputStream，对象操作输入流

可以将序列化到本地文件中的对象，读取到程序中

ObjectInputStream(InputStream out)//把基本流变为高级流
readObject()//可以将序列化到本地文件中的对象，读取到程序中

//1. 创建反序列化流对象
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(""));

//2. 读取数据
Object o=ois.readObject();
//3. 打印对象
//4. 释放资源
ois.close();

如果需要把JavaBean的对象序列化到本地文件中，需要学生类继承序列化接口，alt加回车使用序列化版本ID。

字符流

Reader

FileReader

1. 创建字符输入流对象

FileReader(File file);
FileReader(String pathname);

2. 读取数据

​ read( )一次读一个数据。//直接读取解码成十进制，把十进制作为返回值。

​ read(char[] buffer) 一次读一多个数据。//读取数据，解码，强转合并，把强转后的字符放入数组中。（比空参多了类型转换）

​ 读取一次数据移动一次指针，读到末尾read方法返回-1

3. 释放资源

FileReader fr=new FileReader("C:\\a.txt");
fr.read();//会把文件中的数据放入缓冲区（8192字节数组）
FileWriter fw=new FileWriter("C:\\a.txt");//清空文件
//请问会再次获得数据吗？
int ch;
while((ch=fr.read())!=-1){
    System.out.println((char)ch);//先读取缓冲区中的数据
}
fw.close();
dr.close();

Writer

FileWriter

FileWriter fw=new FileWriter("C:\\a.txt",true);
        fw.write(25105);//写数据
        fw.close();//释放资源

1. 创建字节输出流对象。

   文件不存在会创造新的文件，必须父级路径正确。

   如果文件已经存在，会清空数据。如果不想清空打开续写开关。

2. 写数据。

​ write(int c) 一字符

​ write(String str)一字符串

​ write(String str,int off,int len) 一数组的部分

​ str.getBytes();字符串转换为byte[]

3. 释放资源。

缓冲区写入文件的时刻：

1. 缓冲区满，加入新的数据

   2. 使用flush()将缓冲区中的数据刷新入本地文件
      2. close()释放资源/关流

缓冲流

BufferedReader：readLine（）

BufferedWriterer：newLine（）

转换流

是字节流和字符流转换的桥梁

InputStreamReader,OutputStreamReader

ctrl+p为显示参数

要求：利用字节流读取文件数据，每一次读一行，而且不能出现乱码。

1. 字节流读取中文时候时会出现乱码的，但是字符流可以搞定。
2. 字节流里面没有读一行的方法，只有字符缓冲流可以搞定。

  FileInputStream fis=new FileInputStream("");//字节流
       InputStreamReader isr=new InputStreamReader(fis);//转换流为字符流

        BufferedReader br=new BufferedReader(isr);//字符流转换为缓冲流
   //     String str=br.readLine();
   //    System.out.println(str);
   //    br.close();
		String line;
		while((line=br.readLine())!=null){
            System.out.println(line);  
        }
		br.close();

打印流

特点：打印流只操作文件目的地，不操作数据源（不能读，只能写。）

数据原样写入写出。

特有写出方法，可以自动刷新，自动换行。

字节打印流

PrintStream

字节流底层没有缓冲区，开不开自动刷新都一样。默认自动刷新

//1. 创建字节打印流对象
PrintStream ps=new PrintStream(new FileOutputStream(""),true, Charset.forName("UTF-8"));
//2. 写出数据
ps.println(97);//写出+自动刷新+自动换行
ps.print(true);
ps.printf("%s 喜欢 %s","anzi","quqi");
//3. 释放资源
ps.close();

字符打印流

PrintWriter

字符流底层有缓冲区，可以手动打开自动刷新。

//1. 创建字符打印流对象
PrintWriter pw=new PrintWriter(new FileWriter(""),true, Charset.forName("UTF-8"));
//2. 写出数据
pw.println(97);//写出+自动刷新+自动换行
pw.print(true);
pw.printf("%s 喜欢 %s","anzi","quqi");
//3. 释放资源
pw.close();

特殊的打印流：虚拟机启动时候自动创建,标准输出流。

PrintStream ps=System.out;

ps.println();//写出+自动刷新+自动换行

常用工具包

Commons-io