IO流总结--Day20 / 憋错料

字节为正数，字符为负数

IO流概述
IO流用来处理设备之间的数据传输
上传文件和下载文件
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中

IO流分类
按照数据流向（以Java程序为基准点来看）
输入流读入数据
输出流写出数据
按照数据类型
字节流
字符流
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
如果你什么都不知道，就用字节流

IO流常用基类
字节流的抽象基类：
InputStream (此抽象类是表示字节输入流的所有类的超类)，OutputStream(此抽象类是表示输出字节流的所有类的超类)
字符流的抽象基类：
Reader(用于读取字符流的抽象类) ， Writer(写入字符流的抽象类)
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

/*
* IO流的分类：
*        流向：
*            输入流   读取数据
*            输出流写出数据
*        数据类型：
*            字节流
*                字节输入流   读取数据   InputStream
*                字节输出流   写出数据   OutputStream
*            字符流
*                字符输入流   读取数据   Reader
*                字符输出流   写出数据   Writer
*
*        注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
*
* 需求：我要往一个文本文件中输入一句话："hello,io"
*
* 分析：
*        A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
*        B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
* 通过上面的分析后我们知道要使用：OutputStream
* 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
* 所以，我们要找一个具体的子类。
* 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
* 文件是哪个单词：File
* 然后用的是字节输出流，联起来就是：FileOutputStream
* 注意：每种基类的子类都是以父类名作为后缀名。
*        XxxOutputStream
*        XxxInputStream
*        XxxReader
*        XxxWriter
* 查看FileOutputStream的构造方法：
*        FileOutputStream(File file)
*       FileOutputStream(String name)
*
* 字节输出流操作步骤：
*        A:创建字节输出流对象
*        B:写数据
*        C:释放资源
*/
public class FileOutputStreamDemo {
   public static void main(String[] args) throws IOException {
       // 创建字节输出流对象
       // FileOutputStream(File file)
       // File file = new File("fos.txt");
       // FileOutputStream fos = new FileOutputStream(file);
       // FileOutputStream(String name)
       FileOutputStream fos = new FileOutputStream("fos.txt");
       /*
       * 创建字节输出流对象了做了几件事情：
       * A:调用系统功能去创建文件
       * B:创建fos对象
       * C:把fos对象指向这个文件
       */

       //写数据
       fos.write("hello,IO".getBytes());
       fos.write("java".getBytes());

       //释放资源
       //关闭此文件输出流并释放与此流有关的所有系统资源。
       fos.close();
       /*
       * 为什么一定要close()呢?
       * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
       * B:通知系统去释放跟该文件相关的资源
       */
       //java.io.IOException: Stream Closed
       //fos.write("java".getBytes());
   }
}

/*
* 字节输出流操作步骤：
* A:创建字节输出流对象
* B:调用write()方法
* C:释放资源
*
* public void write(int b):写一个字节
* public void write(byte[] b):写一个字节数组
* public void write(byte[] b,int off,int len):写一个字节数组的一部分
*/

/*
* 如何实现数据的换行?
*        为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
*        如何实现呢?写入换行符号即可呗。
*        刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
*        因为不同的系统针对不同的换行符号识别是不一样的?
*        windows:\r\n
*        linux:\n
*        Mac:\r
*        而一些常见的个高级记事本，是可以识别任意换行符号的。
*
* 如何实现数据的追加写入?
*        用构造方法带第二个参数是true的情况即可
*/
public class FileOutputStreamDemo3 {
   public static void main(String[] args) throws IOException {
       // 创建字节输出流对象
       // FileOutputStream fos = new FileOutputStream("fos3.txt");
       // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
       FileOutputStream fos = new FileOutputStream("fos3.txt", true);

// 写数据
       for (int x = 0; x < 10; x++) {
           fos.write(("hello" + x).getBytes());
           fos.write("\r\n".getBytes());
       }

// 释放资源
fos.close();
}
}

/*
* 加入异常处理的字节输出流操作
*/
最标准的文件字节输出流标准写法：
       // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值，局部代码块变量作用域为括号以内。
       FileOutputStream fos = null;
       try {
           // fos = new FileOutputStream("z:\\fos4.txt");
           fos = new FileOutputStream("fos4.txt");
           fos.write("java".getBytes());
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           // 如果fos不是null，才需要close()
           if (fos != null) {
               // 为了保证close()一定会执行，就放到这里了
               try {
                   fos.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }



标准写法：我自己写的
   public static void send_FileOutputStream(String filePath, byte[] array) {
       FileOutputStream fos = null;
       try {
           fos = new FileOutputStream(filePath);
           fos.write(array);
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       }
       if (fos != null) {
           try {
               fos.close();
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   }

public static void get_FileInputStream(String filePath) {
       FileInputStream fis = null;
       int by = 0;
       try {
           fis = new FileInputStream(filePath);
           while ((by = fis.read()) != -1) {
               System.out.println(by);
           }
       } catch (IOException e) {
           e.printStackTrace();
       } finally {
           if (fis != null) {
               try {
                   fis.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }



package cn.itcast_02;

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

/*
* 字节输入流操作步骤：
* A:创建字节输入流对象
* B:调用read()方法读取数据，并把数据显示在控制台
* C:释放资源
*
* 读取数据的方式：
* A:int read():一次读取一个字节
* B:int read(byte[] b):一次读取一个字节数组
*/
public class FileInputStreamDemo {
   public static void main(String[] args) throws IOException {
       // FileInputStream(String name)
       // FileInputStream fis = new FileInputStream("fis.txt");
       FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

// // 调用read()方法读取数据，并把数据显示在控制台
       // // 第一次读取
       // int by = fis.read();
       // System.out.println(by);
       // System.out.println((char) by);
       //
       // // 第二次读取
       // by = fis.read();
       // System.out.println(by);
       // System.out.println((char) by);
       //
       // // 第三次读取
       // by = fis.read();
       // System.out.println(by);
       // System.out.println((char) by);
       // // 我们发现代码的重复度很高，所以我们要用循环改进
       // // 而用循环，最麻烦的事情是如何控制循环判断条件呢?
       // // 第四次读取
       // by = fis.read();
       // System.out.println(by);
       // // 第五次读取
       // by = fis.read();
       // System.out.println(by);
       // //通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了

// 用循环改进
       // int by = fis.read();
       // while (by != -1) {
       // System.out.print((char) by);
       // by = fis.read();
       // }

// 最终版代码
       int by = 0;
       // 读取，赋值，判断
       while ((by = fis.read()) != -1) {
           System.out.print((char) by);
       }

// 释放资源
fis.close();
}
}

/*
* 一次读取一个字节数组：int read(byte[] b)
* 返回值其实是实际读取的字节个数。
*/
public class FileInputStreamDemo2 {
   public static void main(String[] args) throws IOException {
       // 创建字节输入流对象
       // FileInputStream fis = new FileInputStream("fis2.txt");
       FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

// 读取数据
       // 定义一个字节数组
       // 第一次读取
       // byte[] bys = new byte[5];
       // int len = fis.read(bys);
       // // System.out.println(len);
       // // System.out.println(new String(bys));
       // // System.out.println(new String(bys, 0, len));
       // System.out.print(new String(bys, 0, len));
       //
       // // 第二次读取
       // len = fis.read(bys);
       // // System.out.println(len);
       // // System.out.println(new String(bys));
       // // System.out.println(new String(bys, 0, len));
       // System.out.print(new String(bys, 0, len));
       //
       // // 第三次读取
       // len = fis.read(bys);
       // // System.out.println(len);
       // // System.out.println(new String(bys));
       // // System.out.println(new String(bys, 0, len));
       // System.out.print(new String(bys, 0, len));
       //
       // // 第四次读取
       // len = fis.read(bys);
       // // System.out.println(len);
       // // System.out.println(new String(bys, 0, len));
       // System.out.print(new String(bys, 0, len));
       // // 代码重复了，用循环改进
       // // 但是，我不知道结束条件
       // // len = fis.read(bys);
       // // System.out.println(len);
       // // len = fis.read(bys);
       // // System.out.println(len);
       // // 如果读取到的实际长度是-1，就说明没有数据了

// byte[] bys = new byte[115]; // 0
       // int len = 0;
       // while ((len = fis.read(bys)) != -1) {
       // System.out.print(new String(bys, 0, len));
       // // System.out.print(new String(bys)); //千万要带上len的使用
       // }

// 最终版代码
       // 数组的长度一般是1024或者1024的整数倍
       byte[] bys = new byte[1024];
       int len = 0;
       while ((len = fis.read(bys)) != -1) {
           System.out.print(new String(bys, 0, len));
       }

// 释放资源
fis.close();
}
}

/*
* 复制文本文件。
*
* 数据源：从哪里来
* a.txt   --   读取数据   --   FileInputStream
*
* 目的地：到哪里去
* b.txt   --   写数据       --   FileOutputStream
*
* java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
*
* 这一次复制中文没有出现任何问题，为什么呢?
* 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
* 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
* 它会自己做转换。
*/
public class CopyFileDemo {
   public static void main(String[] args) throws IOException {
       // 封装数据源
       FileInputStream fis = new FileInputStream("a.txt");
       // 封装目的地
       FileOutputStream fos = new FileOutputStream("b.txt");

int by = 0;
       while ((by = fis.read()) != -1) {
           fos.write(by);
       }

// 释放资源(先关谁都行)
       fos.close();
       fis.close();
   }
}

/*
* 需求：把c盘下的a.txt的内容复制到d盘下的b.txt中
*
* 数据源：
*        c:\\a.txt   --   读取数据--   FileInputStream
* 目的地：
*        d:\\b.txt   --   写出数据   --   FileOutputStream
*/
public class CopyFileDemo2 {
   public static void main(String[] args) throws IOException {
       // 封装数据源
       FileInputStream fis = new FileInputStream("c:\\a.txt");
       // 封装目的地
       FileOutputStream fos = new FileOutputStream("d:\\b.txt");

// 复制数据
       int by = 0;
       while ((by = fis.read()) != -1) {
           fos.write(by);
       }