其他分享
首页 > 其他分享> > IO,file速查表

IO,file速查表

作者:互联网

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();
            }
        }
    }
}

标签:file,速查表,字节,File,IO,ready,new,out
来源: https://blog.csdn.net/weixin_43762083/article/details/120870601