Java学习笔记 -IO流1

概述

1. 按照字节的方式读取：

等同于一次读取8个二进制位；
是万能的，什么类型都能读取，包括文本、声音、图片。。
例如：a重点
第一次读取a 一个字节；第二次读取“重”的前半部分一个字节

2. 按照字符去读取数据，一次读取一个字符，为了方便读取普通的文本文件

不能读取除了普通文本之外的任何类型，连Word文件也无法读取
例如：a重点
第一次读取a 一个字节；第二次读取“重” 两个字节

3. Java IO流四大家族

(1)四大首领：

java.io.InputSteam 字节输入流
java.io.OutputStream 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流

(2)相关知识：

以"Stream"结尾都是字节流，以"Reader/Writer"结尾都是字符流
四大家族的首领都是抽象类 (abstract class)
所有流都实现了java.io.closeable接口，都是可以关闭的，都有close()方法
所有的输出流都实现了java.io.Flushable接口,输出流在最终输出之后，一定要flush()
表示刷新一下,这个刷新将管道中剩余的未输出的数据强行输出完，如果没有flush()可能导致数据丢失

4. 16个常用的类

(1)文件专属：

FileInputStream
FileOutputStream
FileReader
FileWriter

(2)转换流：（将字节流转换未字符流）

InputStreamReader
OutputStreamWriter

(3)缓冲流：

BufferedReader
BufferedWriter
BufferedInputStream
BufferedOutputStream

(4)数据流：

DataInputStream
DataOutputStream

(5)标准输出流：

PrintWriter
PrintStream

(6)对象专属流：

ObjectInputStream
ObjectOutputStream

文件专属流

本段通过几个示例程序表述知识点
文件字节流和字符流的用法类似，所以只讲字节流
有一点区别：字节流使用byte[]数组缓存，字符流使用char[]数组缓存
文件字节流读取含中文的普通文本可能会乱码，读取含中文的普通文本最好使用文件字符流

示例1 -FileInputStream：

(1)知识点：

文件路径：绝对路径 & 相对路径
方法：int read() 返回读取字符的编码，如果读取到了文件结尾就返回-1

(2)程序：

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

public class FileInputSteamTest01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            /*
            (1)绝对路径的两种表达:     "\"因为表示转义
            FileInputStream fis = new FileInputStream("D:\biancheng\java\file\chapter19\111.txt");
            fis = new FileInputStream("D:/biancheng/java/file/chapter19/111.txt");
            (2)相对路径：
            IDEA默认的当前目录是工程初始模块的根目录下
             */
            fis = new FileInputStream("src/1/111.txt");

            //如果都到末尾没有数据，会返回-1
            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 -FileInputStream：

(1)知识点：

使用示例1的方法，会造成和硬盘的交互次数过多，应该提高每一次交互所读取的字节数
方法：int read(byte[] b) 一次最多读取b.length个字节,返回读取的字节数,如果读取到了文件结尾就返回-1
常用方法：int available() 返回剩下未读取的字节数量
常用方法：long skip(long n) 跳过n个字节不读，返回实际跳过的字节数目

(2)程序：

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis = null;

        try {
            fis = new FileInputStream("src/1/111.txt");
            
            int retValue = 0;
            //这个方式不适合读大文件，因为bytes数组不能太大
            byte[] bytes = new byte[fis.available()];  //实例化一个和文件字节数相同的byte数组
            fis.skip(3);   //跳过3个字符不读取
            fis.read(bytes);
            System.out.println(new String(bytes));

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

示例3 -FileOutputStream：

(1)知识点：

构造方法：fos = new FileOutputStream(String name,boolean append)
append:是否以追加模式写入，默认是false
其他构造方法查阅参考手册
方法：write(byte b)
write(byte b, int off, int len)
方法：flush(): 在最后一次输出之后，一定要调用flush(),就好像把水管里还剩余的水全部输送出去

(2)程序：

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

public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //以追加模式写入,默认是false
            fos = new FileOutputStream("myfile",true);
            byte[] bytes = {96,97,98,99};
            fos.write(bytes);

            //写入bytes数组的部分内容
            fos.write(bytes, 0, 2);

            //写完之后，一定要刷新一下
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

示例4 -复制文件

重点掌握这种写法

程序：

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

public class CopyTest01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream("D:\迅雷下载\星露谷\README.md");
            fos = new FileOutputStream("D:\myPicture.png");
            //一次读取最多读取1M
            byte[] bytes = new byte[1024 * 1024];
            int retValue = 0;
            while ((retValue = fis.read(bytes)) != -1){
                //一定要指定offset和长度，否则如果读取byte数组不满时，会写入一部分上一次读取的字符
                fos.write(bytes,0,retValue);
            }

            fos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //分别进行try catch,防止一个出现异常，另一个无法关闭
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}