Java之 IO框架

 

File类

我们可以把计算机中所有的文件，文件夹封装成一个File对象

public class File implements Serializable, Comparable<File> {
    
    //有参构造方法，参数为该文件的路径
    public File(String pathname) {
        if (pathname == null) {
            throw new NullPointerException();
        }
        this.path = fs.normalize(pathname);
        this.prefixLength = fs.prefixLength(this.path);
    }
    
    //是否存在
    public boolean exists(){}
    //是否是文件
    public boolean isFile() {}
    //是否是文件夹
    public boolean isDirectory() {}
    //创建该文件夹
    public boolean mkdir() {}
     //创建该文件
    public boolean createNewFile() throws IOException {}
    
    public File[] listFiles() {}
    
    public String getName() {}
    
    public boolean delete() {}
    
    public boolean renameTo(File dest) {}
    
}

流

我们可以通过流，来写入或者读取文件中信息。

分类

按照方向

无论输入，输出相对的都是程序

输入流

（1,0）流入到程序中,读取文件

输出流

流从程序中流出，相当于写入文件

按照单位

字节流

一次读取一个字节，字节流 byte

字符流

一次读取一个字符，字符流

字节输入流

InputStream 字节输入流使用来读取文件，一次读取一个字节

//一次读取一个字节
public abstract int read() throws IOException;
​
//一次读取一个字节，然后放入到数组中
public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}
package com.qfedu;
​
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
​
public class Demo03 {
​
    public static void main(String[] args) throws IOException {
        
        /*
         * 字节输入流   读取文件  一次读取一个字节
         */
        
        //待读取的文件
        File file = new File("D:\\java2203\\first.txt");
        
        //创建该文件的字节输入流
        InputStream is = new FileInputStream(file);
        
        /*
                //读取文件  一次读取一个字节   abcdefg
                int b1 = is.read();  // a 97
                int b2 = is.read();  // b 98
                int b3 = is.read();  // c 99
                int b4 = is.read();  // d 100
                int b5 = is.read();  // e 101
                int b6 = is.read();  // f 102
                int b7 = is.read();  // g 103
                int b8 = is.read();  //-1
                
                System.out.print((char)b1);
                System.out.print((char)b2);
                System.out.print((char)b3);
                System.out.print((char)b4);
                System.out.print((char)b5);
        */
        
        int b;
        while((b = is.read()) != -1) {
            System.out.print((char)b);
        }
        
        is.close();
    }
    
    
}


package com.qfedu;
​
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
​
public class Demo03_2 {
​
    public static void main(String[] args) throws IOException {
        
        /*
         * 把读取到的字节放入一个数组中
         */
        File file = new File("D:\\java2203\\first.txt");
        
        InputStream is = new FileInputStream(file);
        
        byte[] bs = new byte[3];
        
        //abcdefg   a b c, d e f, g 0 0
        
        /*
            int n1 = is.read(bs);
            System.out.println(Arrays.toString(bs)+ n1);
            System.out.println(new String(bs, 0, 3));
            
            int n2 = is.read(bs);
            System.out.println(Arrays.toString(bs)+n2);
            System.out.println(new String(bs, 0, 3));
            
            int n3 = is.read(bs);
            System.out.println(Arrays.toString(bs)+n3);
            System.out.println(new String(bs, 0, 1));
            
            int n4 = is.read(bs);
            System.out.println(n4);
        */
        
        int n;      //读取的字节数
        while((n = is.read(bs)) != -1) {
            System.out.print(new String(bs, 0, n));
        }
        
    }
}

字节输出流

OutputStream 字节输出流使用来写入文件，一次写入一个字节

//一次写入一个字节
public abstract void write(int b) throws IOException;
//一次写入一个字节数组
public void write(byte b[]) throws IOException {}
//一次写入一个字节数组指定位置的字节
public void write(byte b[], int off, int len) throws IOException {}


package com.qfedu;
​
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
​
public class Demo04 {
​
    public static void main(String[] args) throws IOException {
        
        //待写入的文件
        File file = new File("D:\\java2203\\your.txt");
        
        /*
         * 创建该文件对象的输出流  
         * 如果定义添加参数true,则为追加
         * 没有参数true,则为替换
         * 
         */
        OutputStream os = new FileOutputStream(file, true);
        
        //每次写入一个字节
        os.write(97);     //a
        os.write(98);     //b
        os.write('c');
        
        byte[] bs = {100,101,102,103};
        
        os.write(bs);
        
        byte[] bs2 = new byte[10];
        bs2[0] = 104;
        bs2[1] = 105;
        
        os.write(bs2, 0, 2);
        
        os.close();
        
        
        
    }
}

复制文件

复制文件思路：

把使用字节输入流读取到的字节，写入到指定文件中，边读取边写入，达到一个复制的效果。

package com.qfedu;
​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
​
public class Demo05_copy {
​
    /*
     * 使用字节输入，输出，完成复制功能
     */
    public static void main(String[] args) throws IOException {
        //定义待复制的文件
        File file = new File("D:\\java2203\\apache-maven-3.3.9-bin.zip");
        
        //定义复制到的目标文件
        File targetFile = new File("D:\\java2203\\apache-maven-bin.zip");
        targetFile.createNewFile();
        
        //读取待复制文件   获取他的输入流
        InputStream is = new FileInputStream(file);
        
        //写入到目标文件   获取他的输出流
        OutputStream os = new FileOutputStream(targetFile);
        
        int b;
        byte[] bs = new byte[1024];
        while((b = is.read(bs)) != -1) {
            os.write(bs, 0, b);
        }
        
        //关闭资源
        is.close();
        os.close();
    }
    
}

缓冲字节输入流

内部做了优化，减少了和磁盘的交互，提高了字节读取的效率

方法的使用和字节输入流一模一样

package com.qfedu;
​
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
​
public class Demo06 {
​
    /*
     * 缓冲字节输入流
     */
    
    public static void main(String[] args) throws IOException {
        
        //字节输入流
        InputStream is = new FileInputStream("D:\\java2203\\first.txt");
        
        
        //字节输入流，才能创建缓冲字节输入流
        BufferedInputStream bis = new BufferedInputStream(is);
        
        int b;
        byte[] bs = new byte[4];
        while((b = bis.read(bs)) != -1) {
            System.out.print(new String(bs, 0, b));
        }
        
        is.close();
        bis.close();
    }
​
}

缓冲字节输出流

内部做了优化，减少了和磁盘的交互，提高了字节读取的效率

方法的使用和字节输出流一模一样

注意：在最后flush()一下,确保缓存中的数据都写入到磁盘中

package com.qfedu;
​
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
​
public class Demo07 {
​
    public static void main(String[] args) throws IOException {
​
        
        //待写入的文件
        File file = new File("D:\\java2203\\your.txt");
        
        //字符输出流
        OutputStream os = new FileOutputStream(file, true);
        
        //通过字符输出流  获取缓冲字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(os);
        
        String str = "hello world";
        
        byte[] bytes = str.getBytes();
        
        bos.write(bytes);
        bos.flush();     // 抖一抖，把缓冲数据全部写入磁盘中
        
        os.close();
    }
}

字符输入流

字符输入流读取数据，每次读取一个字符

package com.qfedu;
​
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
​
public class Demo08 {
​
    /*
     * 字符输入流 : 读取文件，一次读取一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\his.txt");
        
        //获取该文件的字符输入流
        Reader reader = new FileReader(file);
        
        //你自横刀向天笑，去留肝胆两昆仑。
        
        int c;
        while((c = reader.read()) != -1) {
            System.out.print((char)c);
        }
        
        reader.close();
        
    }
}
package com.qfedu;
​
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
​
public class Demo08_2 {
​
    /*
     * 字符输入流 : 读取文件，一次读取一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\his.txt");
        
        //获取该文件的字符输入流
        Reader reader = new FileReader(file);
        
        //你自横刀向天笑，去留肝胆两昆仑。
        
        int n;
        char[] cs = new char[3];
        while((n = reader.read(cs)) != -1) {
            System.out.print(new String(cs, 0, n));
        }
        
        reader.close();
        
    }
}

字符输出流

字符输出流写入数据，每次写入一个字符

package com.qfedu;
​
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
​
public class Demo09 {
​
    /*
     * 字符输出流，写入到这个文件, 每次写入一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\her.txt");
        
        //获取该文件的字符输出流，写入到这个文件中
        Writer writer = new FileWriter(file);
        
        writer.write(97);       //写入一个字符
        
        char[] arr = {98,99};
        writer.write(arr);      //写入一个字符数组
        
        writer.write("defg");   // 直接写入字符串
        
        writer.close();
    }
    
}

缓冲字符输入流

用法和缓冲字符输入流是一样的

多了一个读取一行数据的方法

package com.qfedu;
​
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
​
public class Demo10 {
​
    /*
     * 字符输入流 : 读取文件，一次读取一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\his.txt");
        
        //获取该文件的字符输入流
        Reader reader = new FileReader(file);
        
        //缓冲字符输入流
        BufferedReader br = new BufferedReader(reader);
        
        
        //你自横刀向天笑，去留肝胆两昆仑。
        
        int c;
        while((c = br.read()) != -1) {
            System.out.print((char)c);
        }
        
        reader.close();
        br.close();
        
    }
}
package com.qfedu;
​
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
​
public class Demo11 {
​
    /*
     * 字符输入流 : 读取文件，一次读取一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\his.txt");
        
        //获取该文件的字符输入流
        Reader reader = new FileReader(file);
        
        /*
         * 缓冲字符输入流
         * 
         *  可以一次读取一行
         */
        BufferedReader br = new BufferedReader(reader);
        
        
        //你自横刀向天笑，去留肝胆两昆仑。
        
        String str;
        while ((str=br.readLine()) != null) {
            System.out.println(str);
        }
        
        reader.close();
        br.close();
        
    }
}

缓冲字符输出流

缓冲字符输出流和字符输出流的用法是一样的

多了一个nextLine()方法，换行方法

package com.qfedu;
​
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
​
public class Demo12 {
​
    /*
     * 字符输出流，写入到这个文件, 每次写入一个字符
     */
    public static void main(String[] args) throws IOException {
        
        File file = new File("D:\\java2203\\her.txt");
        
        //获取该文件的字符输出流，写入到这个文件中
        Writer writer = new FileWriter(file);
        
        //获取该文件的字符输出缓冲流
        BufferedWriter bw = new BufferedWriter(writer);
        
        bw.write(97);       //写入一个字符
        
        char[] arr = {98,99};
        bw.write(arr);      //写入一个字符数组
        
        bw.newLine();  //换行
        
        bw.write("呵呵哒");    // 直接写入字符串
        
        bw.flush();
        
        writer.close();
        bw.close();
    }
    
}