20210816学习

IO流

File

字节流: 针对二级制文件
Inputstream
FileInputStream
BufferedInputStream
ObjectInputStream

OutputStream
FileOutputStream
BufferedOutputStream
ObjectOutputStream

字符流: 针对文本文件
Reader
FileReader
BufferedReader
InputStreamReader
Writer
FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter

package cn.tedu.file;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

/**
 * @author ZHU
 * @create 16/08/2021 09:37
 */
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.创建file独享
        /**
         *1. 构造函数的参数类型是String,代表的是要操作的路径pathname
         * 这个路径既可以是文件路径,也可以是文件夹路径,还可以是不存在的路径
         *
         */

        /**
        2. \ 在代码中有特殊的意义,表示转义符号,
         所以想要表示路径中的\ , 需要写两个才能表示这是一个单纯的 \

         */

        /**
         * 3. 注意: 需要自己手动在D:\ready目录下创建1.txt,并添加内容
         */

        /**
         * 4.创建1.txt时需要设置系统显式文件的后缀名
         * 如果没有设置显示后缀名,文件名应该是1
         */

        //创建file对象时,需要导包

        File file = new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt");

        //2.测试常用方法
        //2.1 文件与文件夹属性
        System.out.println(file.length());
        System.out.println(file.exists());
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
        System.out.println(file.getName());
        System.out.println(file.getParent());
        System.out.println(file.getAbsoluteFile());

        file = new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\zhu");
        /**
         * 如果指定创建文件的路径不存在,会报错:  java.io.IOException
         * 系统找不到指定的路径,就会发生异常,所以调用时需要抛出异常
         */

        //在操作系统中帮我们创建一个原本不存在的文件
        System.out.println(file.createNewFile());
        file = new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\2.txt");
        System.out.println(file.mkdir());

        file = new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\aa\\bb\\cc");
        System.out.println(file.mkdirs());
        /**
         * delete() 只能用来删除文件或者空文件夹
         */
        System.out.println(file.delete());

        //2.3文件列表测试
        file =new File("C:\\Users\\seniorzhu\\Documents\\TestFile");
        String[] list = file.list(); //Alt + Enter 引入局部变量接返回值
        System.out.println(Arrays.toString(list));

        File[] fs = file.listFiles();
        System.out.println(Arrays.toString(fs));
        System.out.println(fs[0]);
        System.out.println(fs[0].length());
    }
}

package cn.tedu.file;

import java.io.*;

/**
 * 本类用于测试字符输入流
 * @author ZHU
 * @create 16/08/2021 11:18
 */
public class TestIn {
    public static void main(String[] args) {
      //  method1();//普通字节流读取
        method2();//高效字节流读取 /缓冲字节输入流

    }

    private static void method2() {
        //1.创建流对象
       /* try {
            new BufferedInputStream(new FileInputStream(new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt")));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/
        InputStream in = null;
        try {
      in  =    new BufferedInputStream(new FileInputStream("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt"));
            //2.使用流对象
    int b;
    while((b = in.read()) != -1){
        System.out.println(b);
    }
            //3.关流




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


    }

    private static void method1() {
        InputStream in = null;

        try {
            //1.创建字节输入流对象用来读取
       /* InputStream in = new InputStream() {
            @Override
            public int read() throws IOException {
                return 0;
            }
        }*/
            //报错,因为抽象父类不可实例化
           //不常用 InputStream in = new FileInputStream(new File("C:\\Users\\seniorzhu\\Documents\\TestFile"));
         in = new FileInputStream("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt");
            //2.使用字节输入流对象
            /**
             * read()  每次调用都会读取一个数据字节,如果读到了数据的末尾,则返回-1
             */
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            System.out.println(in.read());
//            需求: 需要循环中的所有内容,直至结束
            int b;
            while( (b = in.read() )!= -1){
                System.out.println(b);

            }
            //不可以 会跳着读
          /*  while(in.read() != -1){
                System.out.println(in.read());
            }*/
      //  in.close();//关闭流资源
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            /**
             * try-catch 结构中的第三个部分  : finally{}
             * 这个部分指的是无论是否捕获到异常,是一定会被执行到的代码块
             * 所以常常用来关流操作
             */

            //3.关闭流资源
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.file;

import java.io.*;

/**
 * 本类用于练习字符输入流
 * @author ZHU
 * @create 16/08/2021 14:30
 */
public class TestIn2 {
    public static void main(String[] args) {
   //     method1();  //本类用于普通字符流的读取
        method2(); //本类用于普通字符流的读取
    }

    private static void method2() {
        Reader in = null;
        try{
        //1.创建高效流对象
            in = new BufferedReader(new FileReader(""));
            in = new BufferedReader(new FileReader(new File("")));


            //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 method1() {
        //1.创建流对象
       /* Reader in2 = new Reader() {
            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                return 0;
            }

            @Override
            public void close() throws IOException {

            }*/
        Reader in = null;
        try {
            in = new FileReader(new File(""));

            //2.使用流对象
            int  b = 0;

            while(true){
                try {
                    if (!((b = in.read()) != -1)) break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println(b);
            }



        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //3.关闭流对象
}

package cn.tedu.file;

import java.io.*;

/**
 * 本类用于练习自己输出流
 * @author ZHU
 * @create 16/08/2021 16:26
 */
public class TestOut {
    public static void main(String[] args) {
    //    method1();//用于完成普通字节输出流
       method2();//用于完成高效字节输出流
    }

    private static void method2() {
        //1.创建一个在本方法中都生效的局部变量,手动初始化为null
        //2.由于IO操作可能会抛出异常,所以需要try-catch-finally结构
        OutputStream out = null;
        try{
            //3.创建高效流对象
            out = new BufferedOutputStream(new FileOutputStream(new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt"),true));
            //4.通过高效流对象将数据输出到文件中
            out.write(98);
            out.write(98);
            out.write(98);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        //1.创建一个在本方法中都生效的局部变量,手动初始化,值为null
        OutputStream out = null;
        //2.创建try-catch -finally结构,因为IO操作可能会抛出异常
        try{
            //3.创建流对象
            //out = new FileOutputStream(new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt"));
           // out = new FileOutputStream("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt");
            out = new FileOutputStream("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt",true);
            /**
             * FOS的构造函数有一个参数append,默认值为false,表示覆盖
             * 如果设置为true,那么每次输出内容会追加在原来文件内容之后,就不覆盖
             */
            //4.使用流对象
            out.write(97);
            out.write(97);
            out.write(97);

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

package cn.tedu.file;

import java.io.*;

/**
 * 本类用于测试字符输出流
 * @author ZHU
 * @create 16/08/2021 17:22
 */
public class TestOut2 {
    public static void main(String[] args) {
  //      method1();//用于完成普通字符输出流
       method2();//用于完成高效字符输出流
    }

    private static void method2() {

        Writer out = null;
        try{
            //3.创建高效字符输出流对象
        out = new BufferedWriter(new FileWriter(new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt")));
        out = new BufferedWriter(new FileWriter("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt"));

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

    private static void method1() {
        Writer out = null;
        try{
            out = new FileWriter(new File("C:\\Users\\seniorzhu\\Documents\\TestFile\\1.txt"),true);
         //   out = new FileWriter("C:\\Users\\seniorzhu\\Documents\\TestFile\1.txt");

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

字节输入流
InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
–FileInputStream 子类,操作文件的字节输入流,普通类
–BufferedInputStream 子类,缓冲字节输入流,普通类
字符输入流
Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
–FileReader,子类,操作文件的字符输入流,普通类
–BufferedReader,子类,缓冲字符输入流,普通类
字节输出流
OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
–FileOutputStream 子类,操作文件的字节输出流,普通类
–BufferedOutputStream 子类,缓冲字节输出流,普通类
字符输出流
Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
–FileWriter,子类,操作文件的字符输出流,普通类
–BufferedWriter,子类,缓冲字符输出流,普通类