Java(day13)IO流

原创已于 2022-01-19 17:14:36 修改 · 378 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

于 2021-12-16 19:49:16 首次发布

本文详细介绍了Java中的IO流，包括输入流、输出流的分类，如字节流和字符流，并提供了实例代码展示如何进行文件读写。通过BufferedInputStream和BufferedReader等高效流实现数据的高效处理。此外，还演示了文件复制的两种方法，以及JUnit单元测试框架的基本用法。

IO流

在这里插入图片描述

流的分类：

按照流的方向:输入流输出流

按照传输的单位:字节流字符流

字节流：可以处理各种文件

字符流：只能复制有文字的文件

代码分三步：1.找到文件2.读取文件3.关闭文件

组合情况：

字节输入流：

InputStream--抽象父级，不可实例化

FileInputStream--操作字节输入流--构造函数:File/String

BufferedinputStream--高效字节输入流--构造函数：InputStream

高效的优点：可以一次缓存多个数据

read():每次都会读取一个字节，如果读取了数据的末尾，打印出-1

package cn.tedu.file;

import java.io.*;

//本类用于测试字节输入流·
public class TestIn {
    public static void main(String[] args) {
        //Method1();//普通字节输入流
        Method2();//高效字节输入流
    }

    private static void Method2() {
        InputStream in=null;
        try {
            in=new BufferedInputStream(new FileInputStream("D:\\read\\1.txt"));
            int a;
            while((a=in.read())!=-1){
                System.out.println(a);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    
    private static void Method1() {
        InputStream in = null;
        try {
            in=new FileInputStream(new File("D:\\read\\1.txt"));
            int b;
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
运行结果：
98
98
97

字符输入流：

Reader--抽象父类，不可实例化

FileReader--字符输入流--构造函数：File/String

BufferReader--高效字符输入流--构造函数：Reader

package cn.tedu.file;

import java.io.*;
import java.lang.reflect.Method;

//用于测试字符流的读取
public class Testin2 {
    public static void main(String[] args) {
        //method1();//普通字符输入流
        method2();//高效字符输入流

    }

    private static void method2() {
        Reader r= null;
        try {
            r = new BufferedReader(new FileReader("D:\\read\\1.txt"));
            int a;
            while ((a=r.read())!=-1){
                System.out.println(a);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        Reader r=null;
        try {
            r=new FileReader("D:\\read\\1.txt");
            int b;
            while((b=r.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
运行结果：
98
98
97

字节输出流

OutputStream--抽象父级，不可实例化

FileOutputStream--字节输出流--构造函数:File/String/File,append/String,append

BufferOutputStream--高效字节输出流--构造函数：OutputStream

write():写人文件

package cn.tedu.file;

import java.io.*;

//本类用于练习字节输出流
public class TestOut {
    public static void main(String[] args) {
        //method1();//普通字节输出流
        method2();//高效字节输出流
    }

    private static void method2() {
        BufferedOutputStream out=null;
        try {
            //out=new BufferedOutputStream(new FileOutputStream("D:\\read\\1.txt"));//覆盖输出
            //out=new BufferedOutputStream(new FileOutputStream(new File("D:\\read\\1.txt")));//覆盖输出
            //out=new BufferedOutputStream(new FileOutputStream("D:\\read\\1.txt",true));//追加输出
            out=new BufferedOutputStream(new FileOutputStream(new File("D:\\read\\1.txt"),true));
            out.write(121);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        OutputStream o=null;
        try {
            //o=new FileOutputStream("D:\\read\\1.txt");//覆盖输出
            o=new FileOutputStream("D:\\read\\1.txt",true);//追加输出
            int a;
            o.write(97);
            o.write(100);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                o.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

字符输出流：

Writer--抽象父类，不可实例化

FileWriter--字符流输出--构造函数：File/String

BufferedWriter--高效字符流输出--构造函数--Writer

package cn.tedu.file;

import java.io.*;

public class TestOut2 {
    public static void main(String[] args) {
        //method1();//普通字符的输出流
        method2();//高效字符的输出流

    }

    private static void method2() {
        BufferedWriter w=null;
        try {
            //w=new BufferedWriter(new FileWriter("D:\\read\\1.txt"));
            //w=new BufferedWriter(new FileWriter(new File("D:\\read\\1.txt")));
            //w=new BufferedWriter(new FileWriter(new File("D:\\read\\1.txt"),true));
            w=new BufferedWriter(new FileWriter("D:\\read\\1.txt",true));
            w.write(102);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                w.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        Writer w=null;
        try {
            //w=new FileWriter("D:\\read\\1.txt");
            //w=new FileWriter(new File("D:\\read\\1.txt"));
            //w=new FileWriter("D:\\read\\1.txt",true);
            w=new FileWriter(new File("D:\\read\\1.txt"),true);
            w.write(123);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                w.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

文件的复制：

package cn.tedu.file;

import java.io.*;
import java.util.Scanner;

//实现IO综合练习之文件复制案例
public class TestCopyFile {
    public static void main(String[] args) {
        System.out.println("请输入源文件路径");
        String f=new Scanner(System.in).nextLine();
        System.out.println("请输入新文件的路径");
        String t=new Scanner(System.in).nextLine();

        //ZFCopy(f,t);
        ZJCopy(f,t);
    }

    private static void ZJCopy(String f, String t) {
        BufferedInputStream in=null;
        BufferedOutputStream out=null;
        try {
            in=new BufferedInputStream(new FileInputStream(f));
            out=new BufferedOutputStream(new FileOutputStream(t));
            int b;
            while ((b=in.read())!=-1){
                out.write(b);
            }
            System.out.println("文件复制成功");
        } catch (Exception e) {
            System.out.println("文件复制失败");
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void ZFCopy(String f, String t) {
        Reader in=null;
        Writer out=null;
        try {
            in=new BufferedReader(new FileReader(f));
            out=new BufferedWriter(new FileWriter(t));
            int b;
            while((b=in.read())!=-1){
                out.write(b);
            }
            System.out.println("文件复制成功");
        }catch (Exception e){
            System.out.println("文件复制失败");
            e.printStackTrace();
        }finally {
            //关流是有顺序的，如果有多个流，最后创建的流要最先关闭
            //多条关流语句需要各自的try-catch
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

JUnit单元测试框架

要求：public +void +没有参数+@Test

package cn.tedu.file;

import org.junit.Test;

//学习JUnit单元测试框架
public class Demo {
    @Test
    public void eat(){
        System.out.println("哈哈哈");
    }
    @Test
    public void eat2(){
        System.out.println("哈哈哈2");
    }
}