IO流(二）:IO流原理及流的分类

---

1.流的分类

• 按操作数据单位不同分为：字节流（8bit)，字符流（16 bit）
  》对于文本文件(.txt, .java, .c, .cpp)，使用字符流处理。
  》对于非文本文件(.jpg, .mp3, .mp4, .avi, .doc, .ppt,…),使用字节流处理。
• 按数据流的流向不同分为：输入流，输出流
• 按流的角色的不同分为：节点流，处理流

• 1.Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
• 2.由这四个派生出来的子类名称都是以其父类名作为子类名的后缀。

2.IO流体系

3.FileReader读入数据的基本操作

• fr.read()

package com.rufy.java;

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

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 * 将hello.txt文件内容读入程序中,并输出到控制台。
 */
public class Test {
    public static void main(String[] args){
        FileReader fr = null;
        try {
            //1.实例化File类的对象,指明要操作的文件。
            File file = new File("day01\\hello.txt"); //main方法时路径是相较于当前工程
            System.out.println(file.getAbsolutePath());
            //2.提供具体的流
            fr = new FileReader(file);
            //3.数据的读入
            //read()：返回读入的一个字符。如果达到文件末尾,返回-1;
            int data;
            while((data=fr.read())!=-1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            //异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
            try {
                if(fr!=null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

• fr.read(char[] cbuf )

package com.rufy.java;

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

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 * 将hello.txt文件内容读入程序中,并输出到控制台。
 */
public class Test {
    public static void main(String[] args){
        FileReader fr = null;
        try {
            //1.实例化File类的对象,指明要操作的文件。
            File file = new File("day01\\hello.txt"); //main方法时路径是相较于当前工程
            System.out.println(file.getAbsolutePath());
            //2.FileReader流的实例化
            fr = new FileReader(file);
            //3.读入的操作
            //read(char[] cbuf)：返回每次读入cbuf数组中的字符的个数。如果达到文件末尾,返回-1。
            char[] cbuf=new char[5];
            int len;
            while((len=fr.read(cbuf))!=-1){
                //方法一
                for (int i = 0; i <len; i++) {
                    System.out.print(cbuf[i]);
                }
                //方法二
                String str=new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            //异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
            try {
                if(fr!=null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
}

4.FileWriter写出数据的操作

package com.rufy.java;

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

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 * 从内存中写出数据到硬盘的文件里。
 * 说明：
 * 1.输出操作,对应的File可以不存在的,并不会报异常。
 * 2.-File对应磁盘中的文件如果不存在,在输出的过程中,会自动创建此文件。
 *   -File对应的磁盘中的文件如果存在：
 *        --如果流使用的构造器是：FileWriter(file,false)/ FileWriter(file):对原有文件的覆盖。
 *        --如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖,而是在原有文件基础上追加内容。
 *
 */
public class Test {
    public static void main(String[] args) {
        FileWriter fw= null;
        try {
            //1.提供File类的对象,指明写出到的文件
            File file=new File("helloTest.txt");
            //2.提供FileWriter的对象,用于数据的写出
            fw = new FileWriter(file,true);
            //3.写出的操作
            fw.write("I hava a dream!\n");
            fw.write("you need to hava a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //4.流资源的关闭
            try {
                if(fw!=null)
                   fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

       
    }
}

5.使用FileReader和FileWriter实现文本文件的复制

package com.rufy.java;

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

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 *实现从hello.txt读出字符,在写到hello2.txt中
 */
public class Test {
    public static void main(String[] args) {
        FileReader fr= null;
        FileWriter fw= null;
        try {
            //1.创建File类的对象,指明读入和写出的文件
            File srcFile=new File("day01\\hello.txt");
            File destFile=new File("day01\\hello2.txt");
            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf=new char[5];
            int len;  //记录每次读入到cbuf数组中的字符的个数
            while ((len=fr.read(cbuf))!=-1){
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            try {
                if(fw!=null)
                   fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fr!=null)
                 fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

6.使用FileInputStream和FileOutputStream读写非文本文件

package com.rufy.java;

import java.io.*;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 *读取图片和复制图片
 */
public class Test {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            File srcFile = new File("day01\\1.jpg");
            File destFile = new File("day01\\tu.jpg");

            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer=new byte[5];
            int len;
            while ((len=fis.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

7.缓冲流（字节型）实现非文本文件的复制

package com.rufy.java;

import java.io.*;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 * 1.缓冲流：
 *   BufferedInputStream
 *   BufferedOutputStream
 *   BufferedReader
 *   BufferedWriter
 *
 * 2.缓冲流的作用：提高流的读取、写入的速度。
 *   提高读写速度的原因：内部提供了一个缓冲区。
 * 实现非文本文件的复制
 *
 */
public class Test {
    public static void main(String[] args) {
        FileInputStream fis= null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile=new File("day01\\1.jpg");
            File destFile=new File("day01\\fast.jpg");
            //2.造流
            //2.1 造节点流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            //2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.复制的细节:读取、写入
            byte[] buffer=new byte[10];
            int len;
            while((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭资源
            //要求：先关闭外层流,再关闭内层流
            if(bos!=null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //说明：关闭外层流的同时,内层流也会自动的进行关闭。关于内层流的关闭,我们可以省略。
            //fos.close();
            //fis.close();
        }
    }
}

8.缓冲流（字符型）实现文本文件的复制

package com.rufy.java;

import com.sun.xml.internal.ws.util.xml.CDATA;

import java.io.*;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 * 使用BufferedReader和BuferedWriter实现文本文件的复制
 *
 */
public class Test {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("day01\\hello.txt")));
            bw = new BufferedWriter(new FileWriter(new File("day01\\aaa.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf=new char[1024];
//            int len;
//            while ((len=br.read(cbuf))!=-1){
//                bw.write(cbuf,0,len);
//            }

            //方式二：使用String
            String data;
            while ((data=br.readLine())!=null){
                bw.write(data);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(bw!=null)
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(br!=null)
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }



    }
}

8.转换流实现文件的读入和写出

package com.rufy.java;

import com.sun.xml.internal.ws.util.xml.CDATA;

import java.io.*;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 *转换流实现文件的写入和读出
 *
 */
public class Test {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            //1.造文件、造流
            File file1 = new File("day01\\hello.txt");
            File file2 = new File("day01\\hellowrite.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"utf-8");
            osw = new OutputStreamWriter(fos,"gbk");

            //2.读写过程
            char[] cbuf=new char[20];
            int len;
            while ((len=isr.read(cbuf))!=-1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭资源
            if(isr!=null)
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if(osw!=null)
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

    }
}

8.标准的输入、输出流

• System.in : 标准的输入流,默认从键盘输入
• System.out: 标准的输出流,默认从控制台输出

package com.rufy.java;

import com.sun.xml.internal.ws.util.xml.CDATA;

import java.io.*;
import java.sql.SQLOutput;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *
 *1.标准的输入、输出流
 *1.1
 * System.in :标准的输入流,默认从键盘输入
 * System.out:标准的输出流,默认从控制台输出
 *1.2
 * System类的SetIn(InputStream is) / setOut(PrintSteam ps)方式重新指定输入和输出的流
 *
 * 1.3练习：
 *    从键盘输入字符串,要求将读取到的整行字符串转成大写的输出。然后继续进行输入操作，
 *    直至当输入“e"或者”exit"时，退出程序。
 *
 *    方法一：使用Scanner实现,调用next()返回一个字符串
 *    方法二：使用System.in实现。System.in---->转换流---->BufferedReader的readLine()
 */
public class Test {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while(true){
                System.out.println("请输入字符串：");
                String data = br.readLine();
                if("e".equalsIgnoreCase(data)||"exit".equalsIgnoreCase(data)){
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br!=null)
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
}

9.打印流的使用

• System.setOut(PrintSteam ps)

package com.rufy.java;


import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

/**
 * @author Rufy
 * @create 2020-09-08 15:03
 *打印流的使用
 */
public class Test {
    public static void main(String[] args) {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("day01\\打印流.txt"));
            //创建打印输出流,设置为自动刷新模式(写入换行符或字节'\n'时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if(ps!=null){ //把标准输出流（控制台输出）改成输出到文件
                System.setOut(ps);
            }

            for(int i=0;i<255;i++){  //输出ASCII字符
                System.out.print((char) i);
                if(i%50==0){     //每50个数据一行
                    System.out.println();  //换行
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ps!=null)
                ps.close();
        }

    }
}