2021-7-31 IO流 File 字节流 字符流复习

IO流

在java中，根据处理的数据单位的不同，可以把流分为字节流和字符流

字节流：针对二进制文件

字符流：针对文本文件，读写容易出现乱码现象，在读写时，最好指定utf-8

File
字节流:针对二进制文件
InputStream
FileInputStream
BufferedInputStream
ObjectInputStream
OutputStream
FileOutputStream
BufferedOutputStream
ObjectOutputStream
字符流:针对文本文件
Reader
FileReader
BufferedReader
InputStreamReader
Writer
FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter一行行写出

File文件类

new File("D://1.txt") 通过将给定的路径名字符串===》》》抽象路径名来创建一个新的File实例

测试常用方法

package cn.tedu.test;

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

/*1.txt 内容：
* 123李文斌qaz
* */
public class TestFile {
    public static void main(String[] args) throws IOException {
        File file = new File("D://1.txt");
        //文件的字节量
        System.out.println(file.length());//12
        //判断文件是否存在
        System.out.println(file.exists());//true
        //是否为文件
        System.out.println(file.isFile());///true
        //是否为文件夹
        System.out.println(file.isDirectory());//flase
        //获取文件/文件夹名
        System.out.println(file.getName());//1.txt
        //获取父文件名
        System.out.println(file.getParent());//D:\
        //获取该文件完整路径
        System.out.println(file.getAbsolutePath());//D:\1.txt

        /*如果指定创建文件的文件夹不存在，会报错，java.io.IOException
        * 需要抛出异常，创建成功返回true
        * */
        File file1 = new File("D:\\ready\\2.txt");
        System.out.println(file1.createNewFile());//true

        file = new File("D:\\ready\\m");
        System.out.println(file.mkdir());//true,创建不存在的单层文件夹m
        file = new File("D:\\ready\\a\\b\\c");
        System.out.println(file.mkdirs());//true,创建不存在的多层文件夹a/b/c

        System.out.println(file.delete());//c被删除,删除文件或者空文件夹

        file  = new File("D:\\ready\\2.txt");
        System.out.println(file.delete());//true,删除2.txt文件成功

        /*显示文件列表，文件名*/
       File file3 = new File("D:\\ready");
        String[] list = file3.list();
        System.out.println(Arrays.toString(list));
        //显示该文件列表下所有文件的根目录
        File[] fs = file3.listFiles();
        System.out.println(Arrays.toString(fs));
    }
}

字节流读取

InputStream此抽象类是表示字节输入流的所有类的超类/抽象类，不可创建对象

常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源

字符流读取

用来读取字符文件的便捷类

常用方法：
int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分，从off下标开始读len个
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract void close() 关闭该流并释放与之关联的所有资源

package cn.tedu.test;

import java.io.*;
import java.util.Arrays;

public class IoInput {
    public static void main(String[] args) {
        //字节输入流
        // method();
        //高效字节输入流
       // method1();
        //字符输入流
       // method2();
        //高效字符输入流
        method3();
    }
    public static void method(){
        InputStream inputStream = null;
        try {
            inputStream=new FileInputStream("D://ready/1.txt");
            int a=0;
            while (true){
                if ((a=inputStream.read())!=-1){
                    System.out.println(a);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //关流
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    private static void method1() {
        InputStream inputStream = null;
        try {
            inputStream=new BufferedInputStream(new FileInputStream("D://ready/1.txt"));
            int a=0;
            while (true){
                if ((a=inputStream.read())!=-1){
                    System.out.println(a);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method2() {
        Reader reader=null;
        try {
            reader=new FileReader("D://ready/1.txt");
            int a=0;
            while (true){
               if ((a=reader.read())!=-1){
                   System.out.println((char)a);
               }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method3() {
        Reader reader=null;
        try {
            reader=new BufferedReader(new FileReader("D://ready/1.txt"));
            char[] chars=new char[1000];
            reader.read(chars,3,6);
            System.out.println(Arrays.toString(chars));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

字节流写出

常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) 将指定的字节写入此输出流
 

字符流写出

常用方法:
Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分

package cn.tedu.test;

import java.io.*;

public class IoOutput {
    public static void main(String[] args) {
      //字节输出流
        //method();
        //高效字节输出流
        //method1();
        //字符输出流
       //method2();
        //高效字符输出流
        method3();
    }

    public static void method(){
        OutputStream outputStream=null;
        try {
            outputStream=new FileOutputStream("D://ready/2.txt");
            byte[] bytes={65,66,97,98,99};
            outputStream.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method1() {
        OutputStream outputStream=null;
        try {
            outputStream=new BufferedOutputStream(new FileOutputStream("D://ready/2.txt"));
            byte[] bytes={65,66,97,98,99};
            outputStream.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method2() {
        Writer writer=null;
        try {
            writer=new FileWriter("D://ready/2.txt");
            char[] chars={'李','恩','橙'};
            writer.write(chars);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void method3() {
        Writer writer=null;
        try {
            writer=new BufferedWriter(new FileWriter("D://ready/2.txt"));
            char[] chars={'李','恩','橙'};
            writer.write(chars);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

总结:IO的继承结构

1.按照方向进行分类：输入流 输出流（对于程序而言，从程序写数据到文件是输出）

2.按照传输类型：字节流 字符流

3.组合: 字节输入流 字节输出流 字符输入流 字符输出流