1、 构造方法

FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。  

FileOutputStream(FileDescriptor fdObj) 创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。  

FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。 
 
FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。  

FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。  

2、void close()  关闭此文件输出流并释放与此流相关联的任何系统资源。

3、FileChannel getChannel()  返回与此文件输出流相关联的唯一的FileChannel对象。 

4、FileDescriptor getFD()   返回与此流相关联的文件描述符。 

5、字节流写数据的三种方式

void write(byte[] b)  将b.length字节从指定的字节数组写入此文件输出流。  

void write(byte[] b, int off, int len)  将len字节从指定的字节数组开始，从偏移量 off开始写入此文件输出流。  

void write(int b)  将指定的字节写入此文件输出流。

2、字节流写数据如何实现换行

3、使用字节输出流写数据的步骤

4、示例代码：

  public class FileOutputStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字节输出流对象
          //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
          FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
          /*
              做了三件事情：
                  A:调用系统功能创建了文件
                  B:创建了字节输出流对象
                  C:让字节输出流对象指向创建好的文件
           */
  
          //void write(int b)：将指定的字节写入此文件输出流
          fos.write(97);
  //        fos.write(57);
  //        fos.write(55);
  
          //最后都要释放资源
          //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
          fos.close();
      }
  }

  public class FileOutputStreamDemo03 {
      public static void main(String[] args) throws IOException {
          //创建字节输出流对象
  //        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
          FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);
  
          //写数据
          for (int i = 0; i < 10; i++) {
              fos.write("hello".getBytes());
              fos.write("\r\n".getBytes());
          }
  
          //释放资源
          fos.close();
      }
  }

3、字节输入流

1、常用方法

1、构造方法

FileInputStream(File file) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。 
 
FileInputStream(FileDescriptor fdObj) 通过使用文件描述符 fdObj创建 FileInputStream ，该文件描述符表示与文件系统中的实际文件的现有连接。  

FileInputStream(String name) 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。 

2、int available() 返回从此输入流中可以读取（或跳过）的剩余字节数的估计值，而不会被下一次调用此输入流的方法阻塞。  

3、void close() 关闭此文件输入流并释放与流相关联的任何系统资源。  

4、FileChannel getChannel() 返回与此文件输入流相关联的唯一的FileChannel对象。  

5、FileDescriptor getFD() 返回表示与此 FileInputStream正在使用的文件系统中的实际文件的连接的 FileDescriptor对象。  
6、read
int read() 从该输入流读取一个字节的数据。  

int read(byte[] b) 从该输入流读取最多 b.length个字节的数据到一个字节数组。
  
int read(byte[] b, int off, int len) 从该输入流读取最多 len个字节的数据到字节数组。  

7、long skip(long n) 跳过并从输入流中丢弃 n字节的数据。

2、字节输入流读取数据的步骤

3、代码演示

  字节流读数据(一次读一个字节数据)

public class FileInputStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //创建字节输入流对象
          //FileInputStream(String name)
          FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
  
          int by;
          /*
              fis.read()：读数据
              by=fis.read()：把读取到的数据赋值给by
              by != -1：判断读取到的数据是否是-1
           */
          while ((by=fis.read())!=-1) {
              System.out.print((char)by);
          }
  
          //释放资源
          fis.close();
      }
  }

字节流复制文本文件

  public class CopyTxtDemo {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字节输入流对象
          FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
          //根据目的地创建字节输出流对象
          FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗外.txt");
  
          //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
          int by;
          while ((by=fis.read())!=-1) {
              fos.write(by);
          }
  
          //释放资源
          fos.close();
          fis.close();
      }
  }

字节流读数据(一次读一个字节数组数据）

 public class FileInputStreamDemo02 {
      public static void main(String[] args) throws IOException {
          //创建字节输入流对象
          FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
  
          /*
              hello\r\n
              world\r\n
  
              第一次：hello
              第二次：\r\nwor
              第三次：ld\r\nr
  
           */
  
          byte[] bys = new byte[1024]; //1024及其整数倍
          int len;
          while ((len=fis.read(bys))!=-1) {
              System.out.print(new String(bys,0,len));
          }
  
          //释放资源
          fis.close();
      }
  }

字节流复制图片
实现步骤：
  - 根据数据源创建字节输入流对象
  - 根据目的地创建字节输出流对象
  - 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
  - 释放资源

  public class CopyJpgDemo {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字节输入流对象
          FileInputStream fis = new FileInputStream("E:\\itcast\\mn.jpg");
          //根据目的地创建字节输出流对象
          FileOutputStream fos = new FileOutputStream("myByteStream\\mn.jpg");
  
          //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
          byte[] bys = new byte[1024];
          int len;
          while ((len=fis.read(bys))!=-1) {
              fos.write(bys,0,len);
          }
  
          //释放资源
          fos.close();
          fis.close();
      }
  }

三、字节缓冲流

1、介绍

- lBufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

- lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

2、构造方法：

   BufferedOutputStream(OutputStream out)  创建字节缓冲输出流对象 

   BufferedInputStream(InputStream in)    创建字节缓冲输入流对象

3、代码演示

  public class BufferStreamDemo {
      public static void main(String[] args) throws IOException {
          //字节缓冲输出流：BufferedOutputStream(OutputStream out)
   
          BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream\\bos.txt"));
          //写数据
          bos.write("hello\r\n".getBytes());
          bos.write("world\r\n".getBytes());
          //释放资源
          bos.close();
      
  
          //字节缓冲输入流：BufferedInputStream(InputStream in)
          BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream\\bos.txt"));
  
          //一次读取一个字节数据
  //        int by;
  //        while ((by=bis.read())!=-1) {
  //            System.out.print((char)by);
  //        }
  
          //一次读取一个字节数组数据
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              System.out.print(new String(bys,0,len));
          }
  
          //释放资源
          bis.close();
      }
  }

  字节流复制视频

public class CopyAviDemo {
      public static void main(String[] args) throws IOException {
          //记录开始时间
          long startTime = System.currentTimeMillis();
  
          //复制视频
  //        method1();
  //        method2();
  //        method3();
          method4();
  
          //记录结束时间
          long endTime = System.currentTimeMillis();
          System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
      }
  
      //字节缓冲流一次读写一个字节数组
      public static void method4() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
  
          byte[] bys = new byte[1024];
          int len;
          while ((len=bis.read(bys))!=-1) {
              bos.write(bys,0,len);
          }
  
          bos.close();
          bis.close();
      }
  
      //字节缓冲流一次读写一个字节
      public static void method3() throws IOException {
          BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\字节流复制图片.avi"));
  
          int by;
          while ((by=bis.read())!=-1) {
              bos.write(by);
          }
  
          bos.close();
          bis.close();
      }
  
  
      //基本字节流一次读写一个字节数组
      public static void method2() throws IOException {
          //E:\\itcast\\字节流复制图片.avi
          //模块目录下的 字节流复制图片.avi
          FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
          FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
  
          byte[] bys = new byte[1024];
          int len;
          while ((len=fis.read(bys))!=-1) {
              fos.write(bys,0,len);
          }
  
          fos.close();
          fis.close();
      }
  
      //基本字节流一次读写一个字节
      public static void method1() throws IOException {
          //E:\\itcast\\字节流复制图片.avi
          //模块目录下的 字节流复制图片.avi
          FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
          FileOutputStream fos = new FileOutputStream("myByteStream\\字节流复制图片.avi");
  
          int by;
          while ((by=fis.read())!=-1) {
              fos.write(by);
          }
  
          fos.close();
          fis.close();
      }
  }

四、字符流

1、介绍

由于字节流操作中文不是特别的方便，所以Java就提供字符流

字符流 = 字节流 + 编码表

2、编码解码方法

   byte[] getBytes()                        使用平台的默认字符集将该 String编码为一系列字节
    
   byte[] getBytes(String charsetName)      使用指定的字符集将该 String编码为一系列字节 
       
   String(byte[] bytes)                      使用平台的默认字符集解码指定的字节数组来创建字符串
 
   String(byte[] bytes, String charsetName)  通过指定的字符集解码指定的字节数组来创建字符串

代码演示：

  public class StringDemo {
      public static void main(String[] args) throws UnsupportedEncodingException {
          //定义一个字符串
          String s = "中国";
  
          //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
          //byte[] bys = s.getBytes("UTF-8"); //[-28, -72, -83, -27, -101, -67]
          byte[] bys = s.getBytes("GBK"); //[-42, -48, -71, -6]
          System.out.println(Arrays.toString(bys));
  
          //String ss = new String(bys);
          //String ss = new String(bys,"UTF-8");
          String ss = new String(bys,"GBK");
          System.out.println(ss);
      }
  }

3、字符流中的两个类

- InputStreamReader：是从字节流到字符流的桥梁

它读取字节，并使用指定的编码将其解码为字符

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

- OutputStreamWriter：是从字符流到字节流的桥梁

是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

1、 InputStreamReade

1、构造方法
InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
  
InputStreamReader(InputStream in, String charsetName) 创建一个使用命名字符集的InputStreamReader。  

InputStreamReader(InputStream in, Charset cs) 创建一个使用给定字符集的InputStreamReader。
  
InputStreamReader(InputStream in, CharsetDecoder dec) 创建一个使用给定字符集解码器的InputStreamReader。
  
2、void close() 关闭流并释放与之相关联的任何系统资源。  

3、String getEncoding() 返回此流使用的字符编码的名称。 

4、int read() 读一个字符 

5、 int read(char[] cbuf, int offset, int length) 将字符读入数 

6、boolean ready() 告诉这个流是否准备好被读取。

2、OutputStreamWriter

1、构造方法
OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。 
 
OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用命名字符集的OutputStreamWriter。  

OutputStreamWriter(OutputStream out, Charset cs) 创建一个使用给定字符集的OutputStreamWriter。
  
OutputStreamWriter(OutputStream out, CharsetEncoder enc) 创建一个使用给定字符集编码器的OutputStreamWriter。  

2、Writer append(CharSequence csq) 将指定的字符序列附加到此作者。
  
3、Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列附加到此作者。 
 
4、void close() 关闭流，先刷新。  

5、void flush() 刷新流。  

6、String getEncoding() 返回此流使用的字符编码的名称。  

7、void write(char[] cbuf, int off, int len) 写入字符数组的一部分。  

8、void write(int c) 写一个字符  

9、void write(String str, int off, int len) 写一个字符串的一部分。

3、代码演示

  public class ConversionStreamDemo {
      public static void main(String[] args) throws IOException {
          //OutputStreamWriter osw = new OutputStreamWriter(new                                             FileOutputStream("myCharStream\\osw.txt"));
          OutputStreamWriter osw = new OutputStreamWriter(new                                              FileOutputStream("myCharStream\\osw.txt"),"GBK");
          osw.write("中国");
          osw.close();
  
          //InputStreamReader isr = new InputStreamReader(new 	                                         FileInputStream("myCharStream\\osw.txt"));
          InputStreamReader isr = new InputStreamReader(new                                                 FileInputStream("myCharStream\\osw.txt"),"GBK");
          //一次读取一个字符数据
          int ch;
          while ((ch=isr.read())!=-1) {
              System.out.print((char)ch);
          }
          isr.close();
      }
  }

  public class OutputStreamWriterDemo {
      public static void main(String[] args) throws IOException {
          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\osw.txt"));
  
          //void write(int c)：写一个字符
  //        osw.write(97);
  //        osw.write(98);
  //        osw.write(99);
  
          //void writ(char[] cbuf)：写入一个字符数组
          char[] chs = {'a', 'b', 'c', 'd', 'e'};
  //        osw.write(chs);
  
          //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
  //        osw.write(chs, 0, chs.length);
  //        osw.write(chs, 1, 3);
  
          //void write(String str)：写一个字符串
  //        osw.write("abcde");
  
          //void write(String str, int off, int len)：写一个字符串的一部分
  //        osw.write("abcde", 0, "abcde".length());
          osw.write("abcde", 1, 3);
  
          //释放资源
          osw.close();
      }
  }

  public class InputStreamReaderDemo {
      public static void main(String[] args) throws IOException {
     
          InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
  
          //int read()：一次读一个字符数据
  //        int ch;
  //        while ((ch=isr.read())!=-1) {
  //            System.out.print((char)ch);
  //        }
  
          //int read(char[] cbuf)：一次读一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len = isr.read(chs)) != -1) {
              System.out.print(new String(chs, 0, len));
          }
  
          //释放资源
          isr.close();
      }
  }

 2.7字符流复制Java文件

案例需求：把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

- 实现步骤
  - 根据数据源创建字符输入流对象
  - 根据目的地创建字符输出流对象
  - 读写数据，复制文件
  - 释放资源

 public class CopyJavaDemo01 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符输入流对象
          InputStreamReader isr = new InputStreamReader(new FileInputStream("myCharStream\\ConversionStreamDemo.java"));
          //根据目的地创建字符输出流对象
          OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myCharStream\\Copy.java"));
  
          //读写数据，复制文件
          //一次读写一个字符数据
  //        int ch;
  //        while ((ch=isr.read())!=-1) {
  //            osw.write(ch);
  //        }
  
          //一次读写一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len=isr.read(chs))!=-1) {
              osw.write(chs,0,len);
          }
  
          //释放资源
          osw.close();
          isr.close();
      }
  }

字符流复制Java文件改进版

- 案例需求

  使用便捷流对象，把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”

- 实现步骤

  - 根据数据源创建字符输入流对象
  - 根据目的地创建字符输出流对象
  - 读写数据，复制文件
  - 释放资源

- 代码实现

  ```java
  public class CopyJavaDemo02 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符输入流对象
          FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
          //根据目的地创建字符输出流对象
          FileWriter fw = new FileWriter("myCharStream\\Copy.java");
  
          //读写数据，复制文件
  //        int ch;
  //        while ((ch=fr.read())!=-1) {
  //            fw.write(ch);
  //        }
  
          char[] chs = new char[1024];
          int len;
          while ((len=fr.read(chs))!=-1) {
              fw.write(chs,0,len);
          }
  
          //释放资源
          fw.close();
          fr.close();
      }
  }

五、字符缓冲流

1、介绍

- BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

- BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

2、BufferedWriter

1、构造方法
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
  
BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。  

2、void close() 关闭流，先刷新。 
 
3、void flush() 刷新流。  

4、void newLine() 写一行行分隔符。 //特有方法
  
5、void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
  
6、void write(int c) 写一个字符  

7、void write(String s, int off, int len) 写一个字符串的一部分。

3、BufferedReader

1、构造方法
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。  

BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。  

2、void close() 关闭流并释放与之相关联的任何系统资源。  

3、Stream<String> lines() 返回一个 Stream ，其元素是从这个 BufferedReader读取的行。
  
4、void mark(int readAheadLimit) 标记流中的当前位置。  

5、boolean markSupported() 告诉这个流是否支持mark（）操作。  

6、int read() 读一个字符  

7、int read(char[] cbuf, int off, int len) 将字符读入数组的一部分。  

8、String readLine() 读一行文字。   //特有方法

9、boolean ready() 告诉这个流是否准备好被读取。  

10、void reset() 将流重置为最近的标记。  

11、long skip(long n) 跳过字符

4、代码演示

  public class BufferedStreamDemo01 {
      public static void main(String[] args) throws IOException {
          //BufferedWriter(Writer out)
          BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
          bw.write("hello\r\n");
          bw.write("world\r\n");
          bw.close();
  
          //BufferedReader(Reader in)
          BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));
  
          //一次读取一个字符数据
  //        int ch;
  //        while ((ch=br.read())!=-1) {
  //            System.out.print((char)ch);
  //        }
  
          //一次读取一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len=br.read(chs))!=-1) {
              System.out.print(new String(chs,0,len));
          }
  
          br.close();
      }
  }

字符缓冲流复制Java文件

- 案例需求

  把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

- 实现步骤

  - 根据数据源创建字符缓冲输入流对象
  - 根据目的地创建字符缓冲输出流对象
  - 读写数据，复制文件，使用字符缓冲流特有功能实现
  - 释放资源

- 代码实现

  ```java
  public class CopyJavaDemo01 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
          //根据目的地创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
  
          //读写数据，复制文件
          //一次读写一个字符数据
  //        int ch;
  //        while ((ch=br.read())!=-1) {
  //            bw.write(ch);
  //        }
  
          //一次读写一个字符数组数据
          char[] chs = new char[1024];
          int len;
          while ((len=br.read(chs))!=-1) {
              bw.write(chs,0,len);
          }
  
          //释放资源
          bw.close();
          br.close();
      }
  }

  public class BufferedStreamDemo02 {
      public static void main(String[] args) throws IOException {
  
          //创建字符缓冲输出流
          BufferedWriter bw = new BufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));
  
          //写数据
          for (int i = 0; i < 10; i++) {
              bw.write("hello" + i);
              //bw.write("\r\n");
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
  
          //创建字符缓冲输入流
          BufferedReader br = new BufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));
  
          String line;
          while ((line=br.readLine())!=null) {
              System.out.println(line);
          }
  
          br.close();
      }
  }


字符缓冲流特有功能复制Java文件

- 案例需求

  使用特有功能把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java

- 实现步骤

  - 根据数据源创建字符缓冲输入流对象
  - 根据目的地创建字符缓冲输出流对象
  - 读写数据，复制文件，使用字符缓冲流特有功能实现
  - 释放资源

- 代码实现

  ```java
  public class CopyJavaDemo02 {
      public static void main(String[] args) throws IOException {
          //根据数据源创建字符缓冲输入流对象
          BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));
          //根据目的地创建字符缓冲输出流对象
          BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));
  
          //读写数据，复制文件
          //使用字符缓冲流特有功能实现
          String line;
          while ((line=br.readLine())!=null) {
              bw.write(line);
              bw.newLine();
              bw.flush();
          }
  
          //释放资源
          bw.close();
          br.close();
      }
  }