【Java_19】字节流、字符流

① 按流向
    输入流、输出流
② 按类型
    字节流、字符流

* 一切数据在电脑中存储时都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。
* 字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

① void close() 
    关闭此输出流并释放与此流相关联的任何系统资源。  
② void flush() 
    刷新此输出流并强制任何缓冲的输出字节被写出。  
③ void write(byte[] b)
    将 b.length字节从指定的字节数组写入此输出流。  
④ void write(byte[] b, int off, int len) 
    从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。  
⑤ void write(int b) 
    将指定的字节输出流。

① 构造方法
    * public FileOutputStream(File file)
        创建文件输出流以写入由指定的 File对象表示的文件。 
    * public FileOutputStream(String name)
        创建文件输出流以指定的名称写入文件。  
    * public FileOutputStream(File file, boolean append)
        创建文件输出流以写入由指定的 File对象表示的文件。  
    * public FileOutputStream(String name, boolean append)
        创建文件输出流以指定的名称写入文件。 
    示例：
        import java.io.File;
        import java.io.FileOutputStream;
        import java.io.IOException;

        public class OutputStream {
            public static void main(String[] args) throws IOException {
                //追加写
                FileOutputStream fos = new FileOutputStream(new File("C:\\Users\\Demo_Null\\Desktop\\file.java"), true);;
                //覆盖写
                FileOutputStream fos1 = new FileOutputStream("C:\\Users\\Demo_Null\\Desktop\\HelloWorld.java");;
 
                //将字符串转为字节
                fos.write("97".getBytes());
                //将ASCII第65号输出
                fos.write(65);
                //将字符串转为字节
                fos1.write("abc|".getBytes());
                //将ASCII第97号输出
                fos1.write(97);
                
                //刷新
                fos.flush();
                fos1.flush();
                
                //释放资源 释放资源时会先刷新在释放资源，flush()可以不写
                fos.close();
                fos1.close();
            }
        }

① void close()
    关闭此输入流并释放与此流相关联的任何系统资源。    
② int read()
    从输入流读取数据的下一个字节。 
③ int read(byte[] b)
    从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

① 构造方法
    * FileInputStream(File file)
        通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。 
    * FileInputStream(String name)
        通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。  
② 示例
    public class DemoInputStream {
        public static void main(String[] args) throws IOException{
            // 使用文件名称创建流对象
            FileInputStream fis = new FileInputStream("read.txt");
            // 读取数据，返回一个字节
            int read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            read = fis.read();
            System.out.println((char) read);
            // 读取到末尾,返回-1
            read = fis.read();
            System.out.println( read);
            // 关闭资源
            fis.close();
        }
    }

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Date;

public class InputStream {
    public static void main(String[] args) throws IOException {
        //创建输入流
        FileInputStream fis = new FileInputStream("C:\\Users\\Demo_Null\\Desktop\\Desktop.rar");
        //创建输出流
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Demo_Null\\Desktop\\copy.rar");
 
        //读入一个字节（读取->赋值->判断）
        /*int content;
        while ((content = fis.read()) != -1) {
            //写出一个字节
            fos.write(content);
        }*/
 
        //定义一个 1M 缓冲字节数组 
        byte[] bytes = new byte[1024 * 1024];
        //读取到的字节个数
        int len;
 
        //复制文件开始时间
        Date dateStart = new Date();
        long t1 = dateStart.getTime();
        //是否读到末尾
        while ((len = fis.read(bytes)) != -1) {
            //将字节数组从0开始写出len个
            fos.write(bytes,0,len);
        }
 
        //复制文件结束时间
        Date dateEnd = new Date();
        long t2 = dateEnd.getTime();
 
        //复制文件耗时多少毫秒
        System.out.println(t2 - t1);
 
        //释放资源
        fos.close();
        fis.close();
    }
}

① void close()
    关闭此流并释放与此流相关联的任何系统资源。    
② int read()
    从输入流读取一个字符。 
③ int read(char[] cbuf)
    从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。

① 构造方法    
    * FileReader(File file)
        创建一个新的 FileReader ，给定要读取的File对象。   
    * FileReader(String fileName)
        创建一个新的 FileReader ，给定要读取的文件的名称。

① void write(int c)
    写入单个字符。
② void write(char[] cbuf)
    写入字符数组。 
③ void write(char[] cbuf, int off, int len)
    写入字符数组的某一部分,off数组的开始索引,len写的字符个数。 
④ void write(String str)
    写入字符串。 
⑤ void write(String str, int off, int len) 
    写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
⑥ void flush()
    刷新该流的缓冲。  
⑦ void close() 
    关闭此流，但要先刷新它。 

① 构造方法
    * FileWriter(File file)
        创建一个新的 FileWriter，给定要读取的File对象。   
    * FileWriter(String fileName)
        创建一个新的 FileWriter，给定要读取的文件的名称。
        
# GBK中文为2字节而UTF-8中文为3字节故不能直接操作不同的编码文本

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Reader {
    public static void main(String[] args) throws IOException {
        //创建字符输出流
        FileWriter fw = new FileWriter("C:\\Users\\Demo_Null\\Desktop\\chinese.txt");
        //输入字符串到文本
        fw.write("努力工作?\r\n\t↓\r\n升值加薪￥\r\n\t↓\r\n走上人生巅峰<(￣︶￣)↗[GO!]");
        //刷新数据
        fw.flush();
        //释放资源
        fw.close();
 
        //创建字符输入流
        FileReader fr = new FileReader("C:\\Users\\Demo_Null\\Desktop\\chinese.txt");
 
        //创建字符缓冲区
        char[] buffer = new char[1024 * 1024];
        //读取成功的字符数
        int len;
        //判断是否读到结束标记
        while ((len = fr.read(buffer)) != -1) {
            //打印
            System.out.print(new String(buffer,0,len));
        }
        //释放资源
        fr.close();
    }
}