JavaOOP_字节流&字符流！ - 《Java 学习笔记》

1、IO流
- IO流的分类：
- IO流顶级父类们：
2、字节流
3、字符流

1、IO流

我们把数据的传输，看作一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存的是输入流。流出内存的输入流
Java中I/O流主要指使用java.io包下的内容，进行输入，输出操作。输入也叫作读取数据，输出也叫作写出数据

IO流的分类：

根据数据的流向分为：输入流和输出流
输入流：把数据从其他设备读取到内存中的流
输出流：把数据从内存写出到其他设备上的流
格局数据的类型分为：字节流和字符流
字节流：以字节为单位，读写数据的流
字符流：以字符为单位，读写数据的流
硬盘=======输入========》内存
硬盘《=======输出========内存

IO流顶级父类们：

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

2、字节流

一切皆为字节
一切文件数据（文本，图片，视频等）在存储时，都是以二进制数字的形式保存，都是一个一个的字节，那么传输时一样如此，无论使用什么样的流对象，底层传输的始终为二进制数据

OutputStream：

字节输出流的所有类的超类
void Writer（int b）：将指定的字节输出流
void Writer（byte[] b）：将指定的字节数组写入此输出流
void Writer（byte[] b , int off, int len）:从指定的字节数组写入len字节，从偏移量off开始输
void close（）：关闭输出流并释放资源
void flush（）：刷新此输出流并强制任何缓冲的输出字节被写出

FileOutputStream：

文件输出流，用于将数据写出到文件
FileOutputStream（File file）：创建文件输出流写入有指定File对象表示的文件
FileOutputStream（String name）：创建文件输出流以指定的名称写入文件
注意：当创建一个流对象时，必须传入一个文件路径，该路径下如果没有这个文件，会自动创建该文件，如果有改文件，会清空这个文件的数据

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

写单个字节：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 写出数据
          fos.write(97); // 写出第1个字节
          fos.write(98); // 写出第2个字节
          fos.write(99); // 写出第3个字节
          // 关闭资源
        fos.close();
    }
}

写出字节数组：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "我爱Java!".getBytes();
          // 写出字节数组数据
          fos.write(b);
          // 关闭资源
        fos.close();
    }
}

写出指定度字节数组：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
          // 关闭资源
        fos.close();
    }
}

数据的追加续写：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
          // 关闭资源
        fos.close();
    }
}

换行：
如果写的数据较多，那么就会在文件中一行展示，会造成阅读不便，那么需要涉及到换行的问题了
回车符\r和换行符\n：
回车符：回到一行的开头（return）
换行符：下一行（newline）
系统中的换行：
Windows系统：回车+换行，即\r\n；
Linux系统：只有换行，即\n;
Mac系统：只有回车，即\r ,从Mac OS开始与Linux统一，那就也是 \n;

InputStream：

字节输入流的所有的类的超类
void close（）：关闭此输入流，释放资源
int read（）：从输入流读取数据的下一个字节（若为-1，则没有下一个字节了）
int read（byte[] b）：从输入流中读取一些字节数，并将他们储存到字节数组b中

FileInputStream：

文件输入流，从文件读取字节
FileInputStream（File file）：通过打开与实际文件的连接来创建一个FileInputStream
FileInputStream（String name）：通过打开与实际文件的连接创建一个FileInputStream，该文件由系统文件中的路径名name命名
注意：当创建一个流对象时，必须传入一个路径文件，该路径下，如果没有该文件，会抛出FileNotFoundException

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}

一次读取一个字节：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt");
          // 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        fis.close();
    }
}

一次读取一个字节数组：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
        // 关闭资源
        fis.close();
    }
}

图片复制：

public class Copy {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 指定数据源
        FileInputStream fis = new FileInputStream("D:\\test.jpg");
        // 1.2 指定目的地
        FileOutputStream fos = new FileOutputStream("D:\\test_copy.jpg");
        // 2.读写数据
        // 2.1 定义数组
        byte[] b = new byte[1024];
        // 2.2 定义长度
        int len;
        // 2.3 循环读取
        while ((len = fis.read(b))!=-1) {
            // 2.4 写出数据
            fos.write(b, 0 , len);
        }
        // 3.关闭资源
        fos.close();
        fis.close();
    }
}

3、字符流

当使用字节流读取文本文件时，可能会出现一些小问题，就是遇到中文字符时。可能不会显示完整的字符，那是应为一个中文字符可能占用多个字节储存，所以字符流专门用于处理文本文件

Reader：

用于读取字符流的所有类的超类
void close（）：关闭此流，释放资源
int read（）：从输入流读取一个字符
int read（char[] chs）：从输入流读取一些字符，并将他们储存到字符数组chs中去

FileReader：

读取字符文件的便利类，构造时使用系统默认的字符编码和默认字符缓冲区
注意：1、字符编码：字节与字符的对应规则，Windows默认中文编码默认为GBK，idea为UTF8
2、字节缓冲区：一个字节数组，用来临时存储字节数据
FileReader（File file）：创建一个新的FileReader，给定要读取的File对象
FileReader（String fileName）：创建一个新的FileReader，给定要读取的文件的名称
当创建一个流对象时，必须传入一个文件路径

public class FileReaderConstructor throws IOException{
    public static void main(String[] args) {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileReader fr = new FileReader(file);
        // 使用文件名称创建流对象
        FileReader fr = new FileReader("b.txt");
    }
}

一次读取一个字符：

public class FRRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fr.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        fr.close();
    }
}

一次读取一个字符数组;

public class FRRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
         char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf));
        }
        // 关闭资源
        fr.close();
    }
}

Writer:

用于写出字符流的所有类的超类
void write(int c)：写入单个字符
void write（char[] chs）：写入字符数组
void write（char[] chs，off，len）：写入字符数组的某一部分，从off索引开始，写len个
void write（String str）：写入字符串
void write（String str，off，len）：写入字符串的某一部分，从off索引开始，写len个
void flush（）；刷新该流的缓存
void close（）：关闭此流，但要先刷新它

FileWriter：

写出字符到文件的便利类，构造时使用系统默认的字符编码和默认字符缓冲区
FileWriter（File file）：创建一个新的FileWriter，给定要读取的File对象
FileWriter（String fileName）：创建一个新的FileWriter，给定要读取的文件的名称
当创建一个流对象是，必须传入一个文件路径

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
            // 使用File对象创建流对象
        File file = new File("a.txt");
        FileWriter fw = new FileWriter(file);
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("b.txt");
    }
}

一次写一个字符

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 写出数据
          fw.write(97); // 写出第1个字符
          fw.write('b'); // 写出第2个字符
          fw.write('C'); // 写出第3个字符
          fw.write(30000); // 写出第4个字符，中文编码表中30000对应一个汉字。
          /*
        【注意】关闭资源时,与FileOutputStream不同。
           如果不关闭,数据只是保存到缓冲区，并未保存到文件。
        */
        fw.close();
    }
}

flush与close之间的区别

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush 方法了。
flush：刷新缓冲流，流对象可以继续使用
close：先刷新缓冲流，然后通知系统释放资源，流对象不可以再被使用了

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");
        // 写出数据，通过flush
        fw.write('刷'); // 写出第1个字符
        fw.flush();
        fw.write('新'); // 继续写出第2个字符，写出成功
        fw.flush();
          // 写出数据，通过close
        fw.write('关'); // 写出第1个字符
        fw.close();
        fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed
        fw.close();
    }
}

即便是flush写出了数据，最后还是要调用close方法，释放系统资源
一次写一个字符数组：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 字符串转换为字节数组
          char[] chars = "Hello".toCharArray();
          // 写出字符数组
          fw.write(chars); // Hello
        fw.write(b,2,2); 
          // 关闭资源
        fos.close();
    }
}

一次写一个字符串：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 字符串
          String msg = "Hello";
          // 写出字符数组
          fw.write(msg); //Hello
        fw.write(msg,2,2);    
        // 关闭资源
        fos.close();
    }
}

续写和换行：

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象，可以续写数据
        FileWriter fw = new FileWriter("fw.txt"，true);     
          // 写出字符串
        fw.write("hello");
          // 写出换行
          fw.write("\r\n");
          // 写出字符串
          fw.write("world");
          // 关闭资源
        fw.close();
    }
}