IO，file速查表

2024-02-16 08:19:52

1.流的分类：

1）按照方向分类：输入流，输出流

2）按照操作的单位分类：字节流  字符流

3）组合情况：字节输入流 字节输出流 字符输入流  字符输入流

2.字节输入流：

1.抽象父级：InputStream----- 不能实例化

2.普通子级：

FileInputStream----操作文件的字节输入流

构造方法参数：File file  /String pathname

BufferedInputStraem-----高效字节输入流

构造方法参数：InputStream,但无法创建抽象父级对象，所以传的是FileIutputStream

3.字节输出流：

1.抽象父级：OutputStream----- 不能实例化

2.普通子级：

FileOutputStream----操作文件的字节输出流

构造方法参数：File file  / String pathname

注意：默认存在一个参数boolean append，默认值为false，也就是覆盖输出

如果将FileOutputStream构造函数的第2个参数append设置为true，就会实现追加输出的效果

BufferedOutputStraem-----高效字节输出流

构造方法参数：OutputStream,但无法创建抽象父级对象，所以传的是FileOutputStream

4.字符输入流：

 

1.抽象父级：Reader----- 不能实例化

2.普通子级：

FileReader----操作文件的字符输入流

构造方法参数：File file  /String filename

BufferedReader-----高效字符输入流

构造方法参数：InputStream,但无法创建抽象父级对象，所以传的是FileReader

5.字符输出流：

1.抽象父级：Writer----- 不能实例化

2.普通子级：

FileWriter----操作文件的字符输出流

构造方法参数：File file  /String filename

注意：默认存在一个参数boolean append，默认值为false，也就是覆盖输出

如果将FileWriter构造函数的第2个参数append设置为true，就会实现追加输出的效果

BufferedOutputStraem-----高效字节输出流

BufferedWriter-----高效字节输入流

构造方法参数：Writer,但无法创建抽象父级对象，所以传的是FileReader

package cn.tedu.file;

import java.io.File;

public class TestFile {
    public static void main(String[] args) {
        //1.创建file类的对象
        /**
         * ready文件夹与1.txt需要自己手动创建
         * File需要手动导包：import java.io.File
         * 路径pathname是String类型的数据，必须写正确，不然找不到文件
         * 完整的文件名包含两部分：文件名+后缀名
         */
        File file=new File("D:\\ready");
        System.out.println(file.length());
        System.out.println(file.isDirectory());//false,判断当前file对象是一个文件夹
        System.out.println(file.isFile()); //判断当前是文件夹吗
        System.out.println(file.getName());//获取文件本身的名字
        System.out.println(file.getParent());//获取文件父级路径
        System.out.println(file.getAbsoluteFile());//获取带盘符的绝对路径
        System.out.println(file.exists());//获取当前file对象指定的路径是否存在
    }
}
0
true
false
ready
D:\
D:\ready
true

Process finished with exit code 0

操作输入流InputStream fileInputStream

package cn.tedu.file;
import java.io.*;

/**
 * 本类用于练习字节输入流
 */
public class TestIn {
    public static void main(String[] args) {
        method();//字节输入流的读取
    }

    //本方法用于测试字节流的读取
    private static void method() {
      InputStream in = null;
        //1.创建流对象，注意InputStream是抽象父类，不可以实例化。
        try {
             in = new FileInputStream(new File("D:\\ready\\1.txt"));
            InputStream in2 = new FileInputStream("D:\\ready\\1.txt");
           //2.使用流对象，读取指定文件中的数据
            // read()方法每次调用都会读取一个字节，如果读到了文件数据的末尾， 返回-1，
            // 这个方法的返回值是int，所有会查找指定字符对应的编码打印出来
//            System.out.println(in.read());
            //2.2优化代码，使用循环读取
            //定义变量，用来保存本次读到的数据
            int b;
            //循环读取数据，只要读到的数据不等于-1，说明还有数据，符合循环条件，继续循环
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace(); //默认写法：打印错误信息
        }finally {
            /*finally{}代码块是try-catch的第三部分，这部分不论是否捕获异常，都一定会执行，所以常用来关流操作*/
            //3.释放资源，流资源用完必须释放！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

 操作输入流高效InputStream ButterInputStream

package cn.tedu.file;
import java.io.*;

/**
 * 本类用于练习字节输入流
 */
public class TestIn {
    public static void main(String[] args) {
//        method();//字节输入流的读取
        method2();//高效字节输入流的读取

    }

    private static void method2() {
        InputStream in=null;
//        InputStream in=new BufferedInputStream(new FileInputStream(new File("D:\\ready")))
        try {
             in=new BufferedInputStream(new FileInputStream("D:\\ready\\1.txt"));
            //2.使用流对象
            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();
            }
        }
    }

    //本方法用于测试字节流的读取
    private static void method() {
      InputStream in = null;
        //1.创建流对象，注意InputStream是抽象父类，不可以实例化。
        try {
             in = new FileInputStream(new File("D:\\ready\\1.txt"));
            InputStream in2 = new FileInputStream("D:\\ready\\1.txt");
           //2.使用流对象，读取指定文件中的数据
            // read()方法每次调用都会读取一个字节，如果读到了文件数据的末尾， 返回-1，
            // 这个方法的返回值是int，所有会查找指定字符对应的编码打印出来
//            System.out.println(in.read());
            //2.2优化代码，使用循环读取
            //定义变量，用来保存本次读到的数据
            int b;
            //循环读取数据，只要读到的数据不等于-1，说明还有数据，符合循环条件，继续循环
            while((b=in.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace(); //默认写法：打印错误信息
        }finally {
            /*finally{}代码块是try-catch的第三部分，这部分不论是否捕获异常，都一定会执行，所以常用来关流操作*/
            //3.释放资源，流资源用完必须释放！
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package cn.tedu.file;

import java.io.*;

/**
 * 本类用于练习字符输出流writer
 */
public class TestOut2 {
    public static void main(String[] args) {
        method1();//用于测试普通字符输出流
//        method2();//用于测试高效字符输出流

    }

    private static void method2() {
        BufferedWriter out=null;
        try {
//            BufferedWriter out3 = new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt")));
//            BufferedWriter out2 = new BufferedWriter(new FileWriter("D:\\ready\\1.txt"));
//            BufferedWriter out1 = new BufferedWriter(new FileWriter(new File("D:\\ready\\1.txt"), true));
            out = new BufferedWriter(new FileWriter("D:\\ready\\1.txt", true));
        out.write(30);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

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

上一篇：ready概念


下一篇：Centos7.7安装vncserver虚拟网络控制台