（Java总结）io Reader、Writer

package Demo44;

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

/**
 * java.io.Reader:字符输入流，是字符输入流最顶层的父类，是一个抽象类
 * 共性的成员方法：
 *          int read()读取单个字符并返回
 *          int read(char[] cbuf)一次读取多个字符
 *          void close()关闭流并释放资源
 *
 * java.io.FileReader extends InputStreamReader extends Reader
 * FileReader:文件字符输入流
 * 作用：把硬盘文件中的数据以字符的方式读取到内存中
 *
 * 构造方法：
 *      FileReader(String fileName)
 *      FileReader(File file)
 *      参数：String fileName：文件的路径
 *           File file：一个文件
 *       FileReader构造方法的作用
 *          1、创建一个FileReader对象
 *          2、会把FileReader对象指向要读取的文件
 * 使用步骤：
 *  1、创建FileReader对象，构造方法中绑定要读取的数据源
 *  2、使用FileReader对象中的方法read读取文件
 *  3、释放资源
 *
 */

public class DemoReader {
    public static void main(String[] args) throws IOException {
        // 1、创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fs = new FileReader("E:\\daima\\java_day01\\src\\Demo44\\abc");

        //2、使用FileReader对象中的方法read读取文件
        int len = 0;
        while((len = fs.read())!=-1){
            System.out.println((char)len);
        }
        //int read(char[] cbuf)一次读取多个字符
        char[] chars = new char[1024];
        int len1 = 0;
        while((len1=fs.read(chars))!=-1){
            //String类的构造方法
            //String(char[] value)把字符数组转换为字符串
            //String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串，offset为其实索引，count转换的个数

            System.out.println(new String(chars,0,len1));
        }


        //3、释放资源
        fs.close();
    }
}

package Demo44;


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

/*
java.io.Writer: 字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类

共性的成员方法：
    void write(int c)
    void write(char[] cbuf)
    abstract 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()关闭此流，但要先刷新他

java.io.FileWriter extends OutputStreamWriter extends Writer
FileWriter:文件字符输出流
作用：把文件中字符数据写入文件中

构造方法：
    fileWriter(FIle file)根据给定的file对象构造一个FileWriter对象
    FIleWriter(String filename)根据给定的文件构造一个FileWriter对象
    参数：写入数据的目的地
        String fileName:文件的路径
        File file:是一个文件
     构造方法的作用：
        1、会创建一个FileWriter对象
        2、会根据构造方法传递的文件/文件的路径，创建文件
        3、会把FileWriter对象指向创建好的文件

字符输出流的使用步骤：
    1、创建FIleWriter对象，构造方法中绑定要写入数据的目的地
    2、使用FileWriter中的方法write，把数据写入到内存缓冲区中(字符转换为字节的过程)
    3、使用FIleWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
    4、释放资源(会把先把内存缓冲区中的数据刷新到文件中)

 */
public class DemoWriter {
    public static void main(String[] args) throws IOException {
        //1、创建FIleWriter对象，构造方法中绑定要写入数据的目的地
        FileWriter fos = new FileWriter("E:\\daima\\java_day01\\src\\Demo44\\abc");
        //2、使用FileWriter中的方法write，把数据写入到内存缓冲区中(字符转换为字节的过程)
        fos.write("我爱你");
        //3、使用FIleWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
        fos.flush();//刷新之后，流可以继续使用

        //void write(char[] cbuf)
        char[] cs = {'a','b','c','d','e'};
        fos.write(cs);

        // abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分，off数组的开始索引，len写的字符个数
        fos.write(cs,1,3);
        //void write(String str)写入字符串
        fos.write("哈哈哈");
        // void write(String str, int off, int len)写入字符串的某一部分，off字符串的开始索引，len写的字符串的个数
       fos.write("黑马程序员",2,3);
        //4、释放资源(会把先把内存缓冲区中的数据刷新到文件中
        fos.close();//close方法之后流已经关闭了，已经从内存中消失了，就不能再使用了



    }
}

package Demo44;

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

/**
 * 续写和换行：
 *  续写：追加写：使用俩个参数的构造方法
 *      FileWriter(String filename, boolean append)
 *      FileWriter(File file, boolean append)
 *      参数：
 *          String fileName，File file：写入数据的目的地
 *          boolean append：续写开关 true：不会创建型文件覆盖源文件，可以续写，false：创建新的文件覆盖源文件
 *       换行：换行符号
 *       windows:\r\n
 *       linux:/n
 *       mac:/r
 */
public class DemoWriterAN {
    public static void main(String[] args) throws IOException {
        FileWriter fise = new FileWriter("E:\\daima\\java_day01\\src\\Demo44\\abc",true);
        for (int i = 0; i < 10; i++) {
            fise.write("HelloWorld" + i+"\r\n");
        }
        fise.close();
    }
}

package Demo44;
/**
 * JDK1.7之前使用try catch finally处理流中的对象
 * 格式：
 *      try{
 *          可能产生的异常代码
 *      }catch(异常类变量 变量名){
 *          异常处理逻辑
 *      }finally{
 *          一定会执行的代码
 *          资源释放
 *      }
 */

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

public class DemoTryCatch {
    public static void main(String[] args) {
        //如果执行失败，fise就没有值，所以要给赋一个null值
        FileWriter fise = null ;
        try {
            //可能产生的处理逻辑
           fise = new FileWriter("E:\\daima\\java_day01\\src\\Demo44\\abc");
            for (int i = 0; i < 10; i++) {
                fise.write("HelloWorld" + i + "\r\n");
            }
        }catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }finally {
            //一定会执行的代码
            if (fise!=null){
            try {
                fise.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
}

package Demo44;

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

/**
JDK1.7新特性：
    格式：
    try(定义流对象;定义流对象...){
            可能会产生的异常代码
    }catch(异常类变量 变量名){
            异常处理逻辑
 JDK1.9新特性：
 格式：
 A a = new A()
 B b = new B()
 try(a,b){
 可能会产生的异常代码
 }catch(异常类变量 变量名){
 异常处理逻辑
 }
 */
public class DemoJDK7_9TryCatch {
    public static void main(String[] args) {
        try(//    1、创建一个字节输入流对象，构造方法中绑定要读取的数据源
            FileInputStream files = new FileInputStream("E:\\hadoop\\testfile\\ceshi.jpg");
            //    2、创建一个字节输出流对象，构造方法中药绑定要写入的目的地
            FileOutputStream files1 = new FileOutputStream("E:\\hadoop\\testfile\\testfile1\\ceshi.jpg");){
            //   3、使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len=files.read())!=-1){
                files1.write(len);
            }

        }catch (IOException e){
            System.out.println(e);
        }

    }
}