Java学习之IO框架

IO框架

流的概念

概念：内存与存储设备之间传输数据的通道

流的分类

按流向：

• 输入流：将存储设备中的内容读入到内存中。
• 输出流：将内存中的内容写入到存储设备中。

按单位：

• 字节流：以字节为单位，可以读写所有数据。
• 字符流：以字符为单位，只能读写文本数据。

按功能：

• 节点流：具有实际传输数据的读写功能。
• 过渡流：在节点流的基础之上增强功能。

字节流

字节流的父类（抽象类）

• InputStream：字节输入流

  • public int read(){ }
  • public int read(byte[] b) { }
  • public int read(byte[] b,int off ,int len){ }

• OutputStream：字节输出流

  • public int write(int n){ }
  • public int write(byte[] b){ }
  • public int write(byte[] b,int off ,int len){ }

文件字节流

• FileInputStream:
  • public int read(byte[] b)//从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。

package com.xiang.IO;

import java.io.FileInputStream;
/**
 * FileInputStream的使用
 * 文件字节输入流
 */
public class FileInput01 {
    public static void main(String[] args) throws Exception {
        //1创建FileInputStream ,并指定文件路径
        FileInputStream fis= new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //2.1单个字节读取
//        int date=0;
//        while ((date=fis.read())!=-1){
//            System.out.print((char) date);
//        }
        //2.2一次读取多个字节
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=fis.read(buf))!=-1){
            //参数1表示要显示的数组，这里是buf，参数2代表从数组的什么地方开始显示，这是为从下标为0的地方显示，最后一个参数是指显示几个元素，这是是显示count个元素
            System.out.println(new String(buf,0,count ));
        }

        //3关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

package com.xiang.IO;

import java.awt.*;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * 使用文件字节流实现文字的复制
 */
public class FileInput02 {
    public static void main(String[] args) throws Exception {
       //1创建流
        //1.1文件字节输入流
        FileInputStream fis=new FileInputStream("");//读取地址
        //1.2文件字节输出流
        FileOutputStream fos=new FileOutputStream("");//写出地址
        //2 一边读，一边写
        byte[] buf=new byte[1024];
        int count =0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

package com.xiang.IO;

import java.io.FileInputStream;

/**
 * 使用FileInputStream读取文件
 */
public class FileInput03 {
    public static void main(String[] args) throws Exception{
        //1创建FileInputStream对象
        FileInputStream fis=new FileInputStream("d:\\hello.txt");
        //2 读取
        int data=0;
        while ((data=fis.read())!=-1){//12字节 4个汉字
            System.out.print((char) data);
        }

        //3关闭
        fis.close();
    }
}

• FileOutputStream:
  • public int write(byte[] b) //一次写多个字节，将b数组所有字节，写入输出流。

package com.xiang.IO;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

/**
 * FileOutputStream
 */
public class FileOutput01 {
    public static void main(String[] args) throws Exception {
        //1 创建文件字节输出流对象
        FileOutputStream fos=new FileOutputStream("d:\\bbb.txt",true);
        //2 写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string ="helloworld";
        fos.write(string.getBytes());

        //3 关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

字节缓冲流

• 缓冲流：BufferedInputStream/BufferedOutputStream
• 提高IO效率，减少访问磁盘的次数
• 数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close

package com.xiang.IO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class BufferedInput01 {
    public static void main(String[] args) throws Exception{
        //1 创建BufferedInputStream
        FileInputStream fis=new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2读取
//        int date=0;
//        while ((date=bis.read())!=-1){
//            System.out.print((char) date);
//        }
        //
        byte[] buf=new byte[1024];
        int couunt=0;
        while ((couunt=bis.read(buf))!=-1){
            System.out.print(new String(buf,0,couunt));
        }
        //3关闭
        bis.close();

    }
}

package com.xiang.IO;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

/**
 * 使用字节缓冲流写入文件
 * BufferedInputStream
 */
public class BufferedOutput01 {
    public static void main(String[] args) throws Exception{
        //1 创建字节输出缓冲流
        FileOutputStream fos=new FileOutputStream("D:\\ccc.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2写入文件
        for (int i=0;i<10;i++){
            bos.write("helloworld\r\n".getBytes());//先写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        //3关闭(内部会调用flush方法)
        bos.close();
    }
}

对象流

• 对象流：ObjectOutputStream/ObjectInputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能：
    • readObject() 从流中读取一个对象
    • writeObject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化

package com.xiang.IO;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 *
 */
public class ObjectInput01 {
    public static void main(String[] args) throws Exception {
        //1 创建对象流
        FileInputStream fis=new FileInputStream("D:\\stu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);

        //2读取文件（反序列化）
//        Student s = (Student) ois.readObject();
//        Student s2 = (Student) ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();

        //3关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s2.toString());
        System.out.println(list.toString());
    }
   }

package com.xiang.IO;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 注意事项
 * 1.序列化类必须要实现Serializable接口
 * 2.序列化类中对象属性要求实现Serializable接口
 * 3.序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * 4.使用transient（瞬间的）修饰属性，这个属性不能序列化
 * 5.静态属性不能序列化
 * 6.序列化多个对象,可以借助集合实现
 */
public class ObjectOutput01 {
    public static void main(String[] args) throws Exception{
        //1创建对象流
        FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2 序列化（写入操作）
        Student zhangsan =new Student("张三",20);
        Student lisi =new Student("李四",22);
        ArrayList<Student> list=new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
        //3关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

编码方式

字符编码

当编码方式与解码方式不一致时，会出现乱码

字符流

字符流的父类（抽象类）

文件字符流

package com.xiang.IO;

import java.io.FileReader;

/**
 * 使用FileReader读取文件
 *
 */

public class FileReader01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr=new FileReader("d:\\hello.txt");
        //2读取
        //2.1单个字符读取
//        int data=0;
//        while ((data=fr.read())!=-1){//读取一个字符
//            System.out.print((char) data);
//        }
        //2.2多个字符读取
        char[] buf =new char[1024];
        int count =0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        //3关闭
        fr.close();
    }
}

package com.xiang.IO;

import java.io.FileWriter;

/**
 * 使用FileWriter写入文件
 */
public class FileWriter01 {
    public static void main(String[] args)throws Exception {
        //1创建FileWriter对象
        FileWriter fw=new FileWriter("d:\\write.txt");
        //2写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        //3关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

package com.xiang.IO;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 * 使用字节流复制任意文件
 */
public class CopyFile {
    public static void main(String[] args)throws Exception {
        //1.创建FileReader FileWriter
        FileReader fr=new FileReader("d:\\write.txt");
        FileWriter fw=new FileWriter("d:\\write2.txt");

        //2读写
        int data=0;
        while ((data= fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }

        //3关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

• 缓冲流：BufferedReader/BufferedWriter
• 高效读写
• 支持输入换行符
• 可一次写一行、读一行

package com.xiang.IO;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 */
public class BufferedReader01 {
    public static void main(String[] args) throws Exception{
        //创建缓冲流
        FileReader fr=new FileReader("d:\\write.txt");
        BufferedReader br= new BufferedReader(fr);

        //2读取
        //2.1第一种方式
//        char[] buf =new char[1024];
//        int count =0;
//        while ((count=br.read(buf))!=-1){
//            System.out.print(new String(buf,0,count));
//        }

        //2.2第二种方式，一行一行的读取
        String line = null;
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }



        //3关闭
        br.close();
    }
}

package com.xiang.IO;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 演示BufferedWriter的使用
 */
public class BufferedWriter01 {
    public static void main(String[] args) throws Exception{
        //1 创建BufferedWriter对象
        FileWriter fw=new FileWriter("d:\\buffer.txt");
        BufferedWriter bw=new BufferedWriter(fw);

        //2写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上");
            bw.newLine();//写入一个换行符
            bw.flush();
        }
        //3关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

打印流

• PrintWriter：
  • 封装了print() /println() 方法，支持写入后换行
  • 支持数据原样打印

package com.xiang.IO;

import java.io.PrintWriter;

/**
 * 演示PrintWriter的使用
 */
public class PrintWriter01 {
    public static void main(String[] args)throws Exception {
        //1创建打印流
        PrintWriter pw=new PrintWriter("d:\\print.txt");

        //2打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

转换流

• 桥转换流：InputStreamReader/ OutputStreamWriter
  • 可将字节流转换为字符流
  • 可设置字符的编码方式

package com.xiang.IO;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * InputStreamReader读取文件，指定使用的编码
 */
public class InputStreamReader01 {
    public static void main(String[] args)throws Exception {
        //1创建InputStreamReader对象
        FileInputStream fis =new FileInputStream("D:\\write.txt");
        InputStreamReader isr=new InputStreamReader(fis,"utf-8");
        //2.读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char) data);
        }
        //3关闭
        isr.close();
    }
}

package com.xiang.IO;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWriter写入文件，使用指定的编码
 */
public class OutputStreamWriter01 {
    public static void main(String[] args) throws Exception{
        //1创建OutputStreamWriter
        FileOutputStream fos= new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"utf-8");

        //2写入
        for (int i = 0; i < 10; i++) {
            osw.write("卢本伟nb\r\n");
            osw.flush();
        }
        //3关闭
        osw.close();
        System.out.println("执行成功");
    }
}

File类

概念：代表物理盘符中的一个文件或文件夹。

方法：

package com.xiang.IO;

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

/**
 * File类的使用
 * 1.分隔符
 * 2.文件操作
 * 3.文件夹操作
 */
public class File01 {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe();
        directorOpe();
    }
    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //（2）文件操作
    public static void fileOpe()throws Exception{
        //1创建文件
        File file=new File("d:\\file.txt");
//        System.out.println(file.toString());
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果:"+b);
        }

        //2删除文件
        //2.1直接删除
//        System.out.println("删除结果"+file.delete());

        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);

        //3获取文件信息
        System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("获取文件创建时间："+new Date(file.lastModified()).toLocaleString());


        //4判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否可读："+file.canRead());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
    //(3) 文件夹操作
    public static void directorOpe() throws Exception{
        //1 创建文件夹
        File dir= new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
//            dir.mkdir();//只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());

        }
        //2 删除文件夹
        //2.1直接删除（只能删除空目录）
//        System.out.println("删除结果："+dir.delete());
        //2.2使用jvm删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);

        //3 获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取文件夹名称"+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());


        //4 判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏："+dir.isHidden());
        //5 遍历文件夹
        File dir2=new File("C:\\Users\\name\\Desktop\\photo");
        String[] files = dir2.list();
        System.out.println("=============================");
        for (String string:files
             ) {
            System.out.println(string);
        }
            System.out.println("=========FileFilter接口的使用=======");

            File[] files2=dir2.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    if (pathname.getName().endsWith(".png")){
                        return true;
                    }
                    return false;
                }

            });
            for (File file:files2
                 ) {
                System.out.println(file.getName());
            }
        }
    }

FileFilter接口