Java I/O框架 详解

什么是流

概念

• 内存与存储是被之间传输数据的通道

流的分类

• 按方向【重点】
  • 输入流：将<存储设备>中的内容读入到<内存>中
  • 输出流：将<内存>中到内容写入到<存储设备>中
• 按单位：
  • 字节流：以字节为单位，可以读写所有数据
  • 字符流：以字符为单位，只能读写文本数据
• 按功能：
  • 节点流：具有实际传输数据的读写功能
  • 过滤流：在节点流的基础之上增强功能

字节流抽象类

• 字节流的父类（抽象类）：
  • InputStream:字节输入流
    • public int read() {}
    • public int read(byte[] b){}
    • public int read(byte[] b,int off,int len ){}
  • OutputStream:字节输出流
    • publice void write(int n){}
    • pubilce void write(byte[] b){}
    • public int write(byte[] b,int off,int len ){}

FileInputStream的使用

• FileInputStream:
  • publie int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1
• FileOutputStream:
  • public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流

代码片段如下：

/*
 *演示FileInputStream的使用
 * 文件字节输入流 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
//        1创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/aaa.txt");
//        2.读取文件
//        fis.read()
//        单个字节的读取
//        int data = 0;
//        while ((data = fis.read())!=-1) {
//            System.out.print((char) data);
//        }
//        2.2一次读取多个字节
        byte[] buf = new byte[3];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
//        3关闭
        fis.close();
        System.out.println("执行完毕");
    }
}

FileOutputStream的使用

代码片段如下：

/*
 *演示文件字节输出流的使用
 * FileOutputStream
 * */
public class Demo02 {
    public static void main(String[] args) throws Exception{
//        1创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/aaa.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("执行完毕");

    }
}

字节流复制文件

代码片段如下：

/*
 *使用文件字节流实现文件的复制
 * */
public class Demo03 {
    public static void main(String[] args) throws Exception{
//        1创建流
//        1.1文件字节输入流
        FileInputStream fis = new FileInputStream("/Users/apple/Desktop/文件/图片游戏攻略/11.jpg");
//        1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("/Users/apple/Desktop/文件/图片游戏攻略/22.jpg");
//       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("执行完毕");
    }
}

BufferedInputStream的使用

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

代码片段如下：

/*
 * 使用字节缓冲流读取*/
public class demo04 {
    public static void main(String[] args) throws Exception{
//        1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
//        2读取
//        int data =0;
//        while ((data=bis.read())!=-1){
//            System.out.print((char) data);
//        }

//        也可以自己创建一个缓冲区,由自己维护
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
//        3关闭
        bis.close();
    }
}

BufferedOutputStream的使用

代码片段如下：

/*
 *使用字节缓冲流写入文件
 * BufferedOutputStream */
public class Demo05 {
    public static void main(String[] args) throws Exception {
//        1创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
//        2写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("hello\r\n".getBytes());//写入8K缓冲区
            bos.flush();//刷新到硬盘
        }
//        3关闭(内部调用flush方法)
        bos.close();
    }
}

对象流

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

序列化

代码片段如下：

/*
 *使用ObjectOutputStream实现对象的序列化
 * 要求：序列化类必须要实现Serializable接口
 * */
public class Demo06 {
    public static void main(String[] args) throws Exception{
//        1创建对象流
        FileOutputStream fos = new FileOutputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/stu.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
//        2序列化（写入操作）
        Student zhangsan = new Student("张三", 20);
        oos.writeObject(zhangsan);
//        3关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

反序列化

代码片段如下：

/*
 * 使用ObjectInputStream实现反序列化（读取重构对象）*/
public class Demo07 {
    public static void main(String[] args) throws Exception{
//        1创建对象流
        FileInputStream fis = new FileInputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/stu.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
//        2读取文件（反序列化）
        Student o = (Student)ois.readObject();
//        3关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(o.toString());
    }
}

序列化和反序列化注意事项

注意事项

1. 序列化类必须要实现Serializable接口
2. 序列化类对象属性要求实现Serializable接口
3. 序列化版本号ID，保证序列化的类和反序列化的类是同一个类
4. 使用transient(瞬间的、只在内存上的，不能保存到硬盘上)修饰属性，这个属性不能序列化
5. 静态属性不能序列化
6. 序列化多个对象，可以借助集合实现
7. 在遇到StreamCorruptedException异常时的解决办法

https://blog.csdn.net/sunhengzhe/article/details/37773431

参考这个网址的内容

常见字符编码

• ISO-859-1 收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
• UTF-8 针对Unicode码表的可变长度字符编码
• GB2312 简体中文
• GBK 简体中文、扩充
• BIG5 台湾，繁体中文
• 当编码方式和解码方式不一致时，会出现乱码

字符流抽象类

代码片度如下：

用字节流读取字符，会出现乱码

/*
 *使用FileInputStream读取文件
 * */
public class Demo08 {
    public static void main(String[] args) throws Exception{

//        1创建FileInputStream对象
        FileInputStream fis = new FileInputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/hello.txt");
//        2读取
        int data = 0;
        while ((data=fis.read())!=-1){//12个字节4个汉字
            System.out.print((char) data);
        }
//        3关闭
        fis.close();
    }
}

• 字符流的父类（抽象类）

  • Reader:字符输入流
    • public int read(){}
    • public int read(char[] c){}
    • public int read(char[] b,int off,int len){}
  • Writer:字符输出流
    • public void write(int n){}
    • public void write(String str){}
    • public void write(char[] c){}

• 文件字符流

• FileReader:

  • Public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1

• FileWriter:

  • public void write(String str) //一次写入多个字符，将b数组中所有字符，写入输出流

  FileReader的使用

  代码片段如下：

  /*
   *使用FileReader读取文件
   * */
  public class Demo09 {
      public static void main(String[] args) throws Exception{
  //        1创建FileReader 文件字符输入流
          FileReader fr = new FileReader("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/hello.txt");
  //        2读取
  //        2.1单个字符读取
          int data = 0;
          while ((data=fr.read())!=-1){//读取一个字符
              System.out.print((char) data);
          }
          char[] buf = new char[2];
          int count = 0;
          while ((count=fr.read(buf))!=-1){
              System.out.println(new String(buf, 0, count));
          }
  //        3关闭
          fr.close();
      }
  }
  
  

  FileWriter的使用

  代码片段如下：

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

  字符流复制文件

  代码片段如下：

  /*
   * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
   * 使用字节流复制任意文件。*/
  public class Demo11 {
      public static void main(String[] args)throws Exception {
  //        1创建FileReader  FileWriter
          FileReader fr = new FileReader("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/write.txt");
          FileWriter fw = new FileWriter("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/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的使用

• 字符缓冲流

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

/*
 * 使用字符缓冲流读取文件
 * BufferedReader*/
public class Demo12 {
    public static void main(String[] args) throws Exception {
//        1创建缓冲流
        FileReader fr = new FileReader("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/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();
    }
}

BufferedWriter

/*
 * 演示BufferedWriter*/
public class Demo13 {
    public static void main(String[] args) throws Exception{
//        1创建BufferedWriter对象
        FileWriter fw = new FileWriter("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/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的使用

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

代码片段如下：

/*
 * 演示PrintWriter的使用*/
public class Demo14 {
    public static void main(String[] args) throws Exception{
//        1创建打印流
        PrintWriter pw = new PrintWriter("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/print.txt");
//       2打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println(‘a‘);
//        3关闭
        pw.close();
        System.out.println("执行完毕");

    }
}

转换流

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

转换流的使用

代码片段如下：

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

}


/*
 * 使用OutputStreamWriter写入文件，使用指定的编码*/
public class Demo16 {
    public static void main(String[] args) throws Exception{
//        1创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");
//        2写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱北京，我爱故乡\n");
            osw.flush();
        }
//        3关闭
        osw.close();
        System.out.println("执行成功");

    }
}

File类

• 概念：代表物理盘符中的一个文件或者文件夹
• 方法：
  • createNewFile() //创建一个新文件
  • mkdir() //创建一个新目录
  • delete() //删除文件或空目录
  • exists() //判断File对象锁对象锁代表的对象是否存在
  • getAbsoLutePath() //获取文件的绝对路径
  • getName() //取得名字
  • getParent()//获取文件/目录所在的目录
  • isDirectory() //是否是目录
  • isFile() //是否是文件
  • Length() //获得文件的长度
  • listFiles() //列出目录中的所有内容
  • renameTo() //修改文件名为

文件操作

代码片段如下：

/*
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作*/
public class Demo17 {
    public static void main(String[] args) throws Exception{
//        separator();
        fileOpe();
    }
//    （1）分隔符
    public static void separator(){
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }
//    （2）文件操作
    public static void fileOpe() throws IOException, InterruptedException {
//        1创建文件
        File file = new File("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/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(500);
//        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.isFile());
        System.out.println("是否隐藏" + file.isHidden());

    }
}

文件夹操作

代码片段如下：

/*
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作*/
public class Demo17 {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe();
        directoryOpe();
    }
//    （1）分隔符
    public static void separator(){
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }
//    （2）文件操作
    public static void fileOpe() throws IOException, InterruptedException {
//        1创建文件
        File file = new File("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/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(500);
//        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.isFile());
        System.out.println("是否隐藏" + file.isHidden());

    }
//    （5）文件夹操作
    public static void directoryOpe() throws InterruptedException {
//        1创建文件夹
        File dir = new File("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/aaa");
        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("/Users/apple/Desktop/文件");
        String[] files = dir2.list();
        System.out.println("-----------------------");
        for (String file : files) {
            System.out.println(file);
        }

    }
}

FileFilter接口

• pulic interface fileFilter
  • Boolean accept(File pathname)
• 当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现在listFiles()的返回值中。

代码片段如下：

//        5遍历文件夹
        File dir2 = new File("/Users/apple/Desktop/文件/图片游戏攻略");
        String[] files = dir2.list();
        System.out.println("-----------------------");
        for (String file : files) {
            System.out.println(file);
        }
        System.out.println("-------------------");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;
                }
                return false;
            }
        });
        for (File file : files2) {
            System.out.println(file);
        }

    }
}

递归遍历和递归删除

代码片段如下：

/*案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 * */
public class ListDemo {
    public static void main(String[] args) {
//        listDir(new File("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/"));
        deleteDir(new File("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/"));
    }
//    案例1：递归
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }

    }
//    案例2：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }else {
//                    删除文件
                    System.out.println(file.getAbsolutePath() + "删除" + file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath() + "删除：" + dir.delete());
    }
}

Properties

• Properties:属性集合
• 特点
  • 1 存储属性名和属性值
  • 2 属性名和属性值都是字符串类型
  • 3 没有泛型
  • 4 和流有关

Properties的使用

/*演示Properties集合的使用
 * */
public class Demo18 {
    public static void main(String[] args) throws IOException {
//        1创建集合
        Properties properties = new Properties();
//        2添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
//        3遍历
//        3.1--------keyset--------
//        3.2--------entrySet-------
//        3.3-------stringPropertyNames()------
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro : pronames) {
            System.out.println(pro+"======="+properties.getProperty(pro));
        }
//        4和流有关的方法
//        --------list方法---------
        PrintWriter pw = new PrintWriter("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/print.txt");
        properties.list(pw);
        pw.close();
//        ---------2store方法 保存-------
        FileOutputStream fos = new FileOutputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/store.properties");
        properties.store(fos,"注释");
        fos.close();
//        --------3load方法 加载---------
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("/Users/apple/Documents/AmueseWorkspace/ideaProjects/text/store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());


    }
}

Java I/O框架 详解

原文：https://www.cnblogs.com/amuese777/p/14467499.html