IO

IO框架

流

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

流的分类

• 按方向怕【重点】

  • 输入流：讲<存储设备>中的内容读入到<内存>中。

  • 输出流：讲<内存>中的内容写入到<存储设备>中

• 按单位：

  • 字节流：以字节为单位，可以读写所有数据。

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

• 按功能

  • 节点流：具有实际传输数据的读写功能。

  • 过滤流：在节点流的基础之上增强功能。

字节流

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

  • InputStream：字节输入流

    • 子类：FileInputStream

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

  package com.IO;
  ​
  ​
  import java.io.FileInputStream;
  ​
  /**
   * 演示FileInputStream的使用
   * 文件字节输入流
   * */
  public class Demo01 {
      public static void main(String[] args) throws Exception{
          //1创建一个FileInputStream,并指定文件路径
          FileInputStream fis = new FileInputStream("D:\\IOtest\\aaa.txt");
          //2读取文件
          //fis.read();因为该方法每次只能读一个字节，所以要用循环来实现
          //2.1 单个字节读取 效率不高
          /*int date=0;
          while ((date=fis.read())!=-1){
              System.out.println((char) date);
          }*/
          //2.2一次读取多个字节
          byte[] buf=new byte[1024];
  ​
          int count=0;
          while ((count=fis.read(buf))!=-1){
              System.out.println(new String(buf,0,count));
          }
          fis.close();
          System.out.println("执行完毕");
  ​
      }
  }

  • OutputStream：字节输出流

    • 子类：FileOutputStream：

      • 方法：public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流。

package com.IO;
​
import java.io.FileOutputStream;
​
/**
 * 字节输出流
 * 演示FileOutputStream
 * */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //创建一个字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\bbb.txt",true);
        //每次写入都会覆盖掉上次写的数据，若不想覆盖，则需要在实例化的时候 往参数里加入true
        //写入文件
        /*fos.write(97);
        fos.write('b');
        fos.write('c');*/
        String string="helloworld";
        fos.write(string.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

案例：复制文件

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
​
//案例：复制文件
public class Demo03 {
    public static void main(String[] args) throws Exception {
        //创建文件输入流
        FileInputStream fis = new FileInputStream("D:\\IOtest\\001.JPG");
        //文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\002.JPG");
        //2一边读一边写
        byte[] buf=new byte[1024];
​
        int count=0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        fos.close();
        fis.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

• 缓冲流：BufferedInputStream/BufferedOutputStream

  • 提高IO效率，减少访问磁盘的次数；

  • 数据存储在缓冲区中，fiush是将缓存区的内容写入文件中，也可以直接close

• BufferedInputStream内部存在一个8k的缓冲区

package com.IO;
​
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws Exception {
        //1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("D:\\IOtest\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //读取
        int date=0;
        while ((date=bis.read())!=-1){
            System.out.print((char)date);
        }
        //关闭
        bis.close();
    }
​
}

• BufferedOutputStream数据先存入缓冲区中，等到关闭的时候在刷新到硬盘

package com.IO;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
​
/*
* 使用字节缓冲流输出
* BufferedOutputStream
* */
public class Demo05 {
    public static void main(String[] args) throws Exception {
        //创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\r\n".getBytes());//先写入的缓冲区中
            bos.flush();//刷新到硬盘
        }
        //3.关闭（内存调用flush方法）
        bos.close();
    }
}

对象流

• 对象流：ObjectOutputStream/ObjectInputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串功能

  • 增强了读写对象的功能

    • readObject() 从流中读取一个对象

    • writeObject（Object obj）向流中写入一个对象

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

注意：

1. 要想序列化，实例化的对象的类必须要实现Serializable接口

2. 序列化类中对象属性要求实现Serializabie接口

3. 序列化版本号ID serialVersionUID,保证序列化的类和反序列的类是同一个类

4. 使用transient（瞬间的）修饰属性，这个属性不能序列化

5. 静态属性不能序列化

6. 序列化多个对象，可以借助集合实现

注：此接口为一个标记接口，内无任何方法无任何属性

序列化

//1创建对象流
FileOutputStream fos = new FileOutputStream("D:\\IOtest\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2实现序列化（写入操作）
Student lcj = new Student("lcj", 20);
oos.writeObject(lcj);
//关闭
oos.close();
System.out.println("序列化完毕");

反序列化

//创建对象流
FileInputStream fis = new FileInputStream("D:\\IOtest\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取文件（反序列化）
Student s=(Student)ois.readObject();
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());

集合序列化

ArrayList<Student> list=new ArrayList<>();
list.add(lcj);
list.add(lh);
oos.writeObject(list);

集合反序列化

ArrayList<Student> s= (ArrayList<Student>) ois.readObject();
ois.close();
System.out.println(s);

字符流

常见的字符编码

• ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号

• UTF-8 针对Unicode码表的可变长字符编码

• GB2312 简体中文

• GBK 简体中文、扩充

• BIG5 台湾，繁体中文

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

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

  • Reader:字符输入流

    • public int read(){}

    • public int reae(char[] c){}

    • public int reae(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；

  package com.IO;
  ​
  import java.io.FileReader;
  ​
  /**
   * 使用FileReader读取文件
   */
  public class Demo08 {
      public static void main(String[] args) throws Exception{
          //创建FileReader 文件字符输入流
          FileReader fr=new FileReader("D:\\IOtest\\hello.txt");
          //读取
          //1.单个字符读取
          int date=0;
          while ((date=fr.read())!=-1){//读取的时字符
              System.out.print((char) date);
          }
          //2.创建字符缓冲区
          char[] buf=new char[1024];
          int count=0;
          while ((count=fr.read(buf))!=-1){
              System.out.println(new String(buf,0,count));
          }
          fr.close();
      }
  }

  • FileWriter：

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

package com.IO;
​
import java.io.FileWriter;
​
public class Demo09 {
    public static void main(String[] args) throws Exception{
        FileWriter fw=new FileWriter("D:\\IOtest\\writer.txt");
        for (int i = 0; i < 10; i++) {
            fw.write("良好真护士");
            fw.flush();
        }
        fw.close();
        System.out.println("执行完毕");
    }
}

字符缓冲流

• 缓冲流：BufferedReader/BufferedWriter

  • 高效读写

  • 支持输入换行符

  • 可一次写一行、读一行。

BufferedReader的使用

//一行一行的读取
String line=null;
while ((line=br.readLine())!=null){
    System.out.println(line);
}

BufferedWriter的使用

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

打印流

• PrintWriter

  • 封装了print（）/println（）方法，支持写入后换行

  • 支持数据原样打印

//1创建一个打印流
PrintWriter pw=new PrintWriter("D:\\IOtest\\print.txt");
//打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
//关闭
pw.close();
System.out.println("执行完毕");

转换流

• 桥转换流：InputStreamReader/OutputSteramWriter

  • 可将字节流转换为字符流

  • 可设置字符的编码方式。

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
​
/**
 * 使用InputStreamReader读取文件，指定使用的编码
 * 使用OutputStreamReader读取文件，指定使用的编码
 */
public class Demo14 {
    public static void main(String[] args) throws Exception {
    //1.创建InputStreamReader
        FileInputStream fis=new FileInputStream("D:\\IOtest\\print.txt");
        InputStreamReader isr=new InputStreamReader(fis,"gbk");
     //创建OutputStreamReader
        FileOutputStream fos=new FileOutputStream("D:\\IOtest\\print2.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        //读取文件
        int data=0;
        while ((data=fis.read())!=-1){
            System.out.println((char) data);
        }
        //写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱编程\r\n");
            osw.flush();
        }
        //关闭
        isr.close();
        osw.close();
        System.out.println("创建完成");
    }
}

File类

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

• 方法：

  • createNewFile（）//创建一个新文件

  • mkdir()//创建一个新目录

  • delete()//删除文件或空目录

  • exists()//判断File对象所对象所代表的对象是否存在

  • getAbsolutePath()//获取文件的绝对路径

  • getName()//取的名字

  • getParent()//获取文件/目录所在的目录

  • isDirectory()//是否是目录

  • isFile()//是否是文件

  • length()//获得文件的长度

  • listFiles()//列出目录中的所有内容

  • renameTo()//修改文件名为

package com.IO;
​
import java.io.File;
import java.util.Date;
​
/**
 * File类的使用
 *（1）分隔符
 *（2）文件操作
 *（3）文件夹操作
 */
public class Demo15 {
    public static void main(String[] args)throws Exception {
        //separator();
       //filrOpe();
        directoryOpe();
    }
    //（1）分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+ File.separator);
    }
    //（2）文件操作
    public static void filrOpe()throws Exception{
        //1.创建文件
        File file = new File("D:\\file.txt");
        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("文件创建时间"+file.lastModified());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
    //(3)文件夹操作
    public static void directoryOpe()throws Exception{
        //创建文件夹
        File dir=new File("d:\\IOtest\\aaa");
        if (!dir.exists()){
            System.out.println("创建结果"+dir.mkdir());
            //dir.mkdirs();//创建多级目录
        }
        //删除文件夹
        //2.1直接删除
        //System.out.println("创建结果"+dir.delete());//只能删除最底层的文件夹，且为空目录
        //2.1使用jvm来删除
        //dir.deleteOnExit();
        //Thread.sleep(5000);
        //获取文件夹信息
        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());
​
        //判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否是隐藏"+dir.isHidden());
        //遍历文件夹
        File dir2=new File("D:\\IOtest");
        String[] files=dir2.list();
        System.out.println("===================");
        for (String string:
             files) {
            System.out.println(string);
        }
    }
}

FileFilter接口

• public interface FileFilter

  • boolean accept(File pathname)

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

System.out.println("=========FileFilter接口==========");

File[] files1=dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().endsWith(".JPG")) {
            return true;
        }
        return false;
    }
});
for (File file:
     files1) {
    System.out.println(file);
}

递归遍历和递归删除

• 递归遍历

public static void listDir(File dir){
    File[] files=dir.listFiles();
    System.out.println(dir.getAbsolutePath());
    if (files!=null&&files.length>0){
        for (File file:files) {
            if (file.isDirectory()){
                listDir(file);
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

• 递归删除

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. 和流有关

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
​
/**
 * 演示Properties集合的使用
 */
public class Demo16 {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties = new Properties();
        //添加
        properties.setProperty("uesrname","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //遍历
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:
             pronames) {
            System.out.println(pro+"++++++++"+properties.getProperty(pro));
        }
        //和流有关的方法
        //=====list======、
        PrintWriter pw=new PrintWriter("d:\\print.txt");
        properties.list(pw);
        pw.close();
        //==========store方法===========
        FileOutputStream fos=new FileOutputStream("d:\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        //============load方法 加载============
        Properties properties1=new Properties();
        FileInputStream fis=new FileInputStream("d:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}

IO框架

流

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

流的分类

• 按方向怕【重点】

  • 输入流：讲<存储设备>中的内容读入到<内存>中。

  • 输出流：讲<内存>中的内容写入到<存储设备>中

• 按单位：

  • 字节流：以字节为单位，可以读写所有数据。

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

• 按功能

  • 节点流：具有实际传输数据的读写功能。

  • 过滤流：在节点流的基础之上增强功能。

字节流

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

  • InputStream：字节输入流

    • 子类：FileInputStream

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

  package com.IO;
  ​
  ​
  import java.io.FileInputStream;
  ​
  /**
   * 演示FileInputStream的使用
   * 文件字节输入流
   * */
  public class Demo01 {
      public static void main(String[] args) throws Exception{
          //1创建一个FileInputStream,并指定文件路径
          FileInputStream fis = new FileInputStream("D:\\IOtest\\aaa.txt");
          //2读取文件
          //fis.read();因为该方法每次只能读一个字节，所以要用循环来实现
          //2.1 单个字节读取 效率不高
          /*int date=0;
          while ((date=fis.read())!=-1){
              System.out.println((char) date);
          }*/
          //2.2一次读取多个字节
          byte[] buf=new byte[1024];
  ​
          int count=0;
          while ((count=fis.read(buf))!=-1){
              System.out.println(new String(buf,0,count));
          }
          fis.close();
          System.out.println("执行完毕");
  ​
      }
  }

  • OutputStream：字节输出流

    • 子类：FileOutputStream：

      • 方法：public void write(byte[] b)//一次写多个字节，将b数组中所有字节，写入输出流。

package com.IO;
​
import java.io.FileOutputStream;
​
/**
 * 字节输出流
 * 演示FileOutputStream
 * */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //创建一个字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\bbb.txt",true);
        //每次写入都会覆盖掉上次写的数据，若不想覆盖，则需要在实例化的时候 往参数里加入true
        //写入文件
        /*fos.write(97);
        fos.write('b');
        fos.write('c');*/
        String string="helloworld";
        fos.write(string.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

案例：复制文件

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
​
//案例：复制文件
public class Demo03 {
    public static void main(String[] args) throws Exception {
        //创建文件输入流
        FileInputStream fis = new FileInputStream("D:\\IOtest\\001.JPG");
        //文件字节输出流
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\002.JPG");
        //2一边读一边写
        byte[] buf=new byte[1024];
​
        int count=0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        fos.close();
        fis.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

• 缓冲流：BufferedInputStream/BufferedOutputStream

  • 提高IO效率，减少访问磁盘的次数；

  • 数据存储在缓冲区中，fiush是将缓存区的内容写入文件中，也可以直接close

• BufferedInputStream内部存在一个8k的缓冲区

package com.IO;
​
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws Exception {
        //1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("D:\\IOtest\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //读取
        int date=0;
        while ((date=bis.read())!=-1){
            System.out.print((char)date);
        }
        //关闭
        bis.close();
    }
​
}

• BufferedOutputStream数据先存入缓冲区中，等到关闭的时候在刷新到硬盘

package com.IO;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
​
/*
* 使用字节缓冲流输出
* BufferedOutputStream
* */
public class Demo05 {
    public static void main(String[] args) throws Exception {
        //创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("D:\\IOtest\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld\r\n".getBytes());//先写入的缓冲区中
            bos.flush();//刷新到硬盘
        }
        //3.关闭（内存调用flush方法）
        bos.close();
    }
}

对象流

• 对象流：ObjectOutputStream/ObjectInputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串功能

  • 增强了读写对象的功能

    • readObject() 从流中读取一个对象

    • writeObject（Object obj）向流中写入一个对象

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

注意：

1. 要想序列化，实例化的对象的类必须要实现Serializable接口

2. 序列化类中对象属性要求实现Serializabie接口

3. 序列化版本号ID serialVersionUID,保证序列化的类和反序列的类是同一个类

4. 使用transient（瞬间的）修饰属性，这个属性不能序列化

5. 静态属性不能序列化

6. 序列化多个对象，可以借助集合实现

注：此接口为一个标记接口，内无任何方法无任何属性

序列化

//1创建对象流
FileOutputStream fos = new FileOutputStream("D:\\IOtest\\stu.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//2实现序列化（写入操作）
Student lcj = new Student("lcj", 20);
oos.writeObject(lcj);
//关闭
oos.close();
System.out.println("序列化完毕");

反序列化

//创建对象流
FileInputStream fis = new FileInputStream("D:\\IOtest\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取文件（反序列化）
Student s=(Student)ois.readObject();
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());

集合序列化

ArrayList<Student> list=new ArrayList<>();
list.add(lcj);
list.add(lh);
oos.writeObject(list);

集合反序列化

ArrayList<Student> s= (ArrayList<Student>) ois.readObject();
ois.close();
System.out.println(s);

字符流

常见的字符编码

• ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号

• UTF-8 针对Unicode码表的可变长字符编码

• GB2312 简体中文

• GBK 简体中文、扩充

• BIG5 台湾，繁体中文

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

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

  • Reader:字符输入流

    • public int read(){}

    • public int reae(char[] c){}

    • public int reae(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；

  package com.IO;
  ​
  import java.io.FileReader;
  ​
  /**
   * 使用FileReader读取文件
   */
  public class Demo08 {
      public static void main(String[] args) throws Exception{
          //创建FileReader 文件字符输入流
          FileReader fr=new FileReader("D:\\IOtest\\hello.txt");
          //读取
          //1.单个字符读取
          int date=0;
          while ((date=fr.read())!=-1){//读取的时字符
              System.out.print((char) date);
          }
          //2.创建字符缓冲区
          char[] buf=new char[1024];
          int count=0;
          while ((count=fr.read(buf))!=-1){
              System.out.println(new String(buf,0,count));
          }
          fr.close();
      }
  }

  • FileWriter：

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

package com.IO;
​
import java.io.FileWriter;
​
public class Demo09 {
    public static void main(String[] args) throws Exception{
        FileWriter fw=new FileWriter("D:\\IOtest\\writer.txt");
        for (int i = 0; i < 10; i++) {
            fw.write("良好真护士");
            fw.flush();
        }
        fw.close();
        System.out.println("执行完毕");
    }
}

字符缓冲流

• 缓冲流：BufferedReader/BufferedWriter

  • 高效读写

  • 支持输入换行符

  • 可一次写一行、读一行。

BufferedReader的使用

//一行一行的读取
String line=null;
while ((line=br.readLine())!=null){
    System.out.println(line);
}

BufferedWriter的使用

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

打印流

• PrintWriter

  • 封装了print（）/println（）方法，支持写入后换行

  • 支持数据原样打印

//1创建一个打印流
PrintWriter pw=new PrintWriter("D:\\IOtest\\print.txt");
//打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.println('a');
//关闭
pw.close();
System.out.println("执行完毕");

转换流

• 桥转换流：InputStreamReader/OutputSteramWriter

  • 可将字节流转换为字符流

  • 可设置字符的编码方式。

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
​
/**
 * 使用InputStreamReader读取文件，指定使用的编码
 * 使用OutputStreamReader读取文件，指定使用的编码
 */
public class Demo14 {
    public static void main(String[] args) throws Exception {
    //1.创建InputStreamReader
        FileInputStream fis=new FileInputStream("D:\\IOtest\\print.txt");
        InputStreamReader isr=new InputStreamReader(fis,"gbk");
     //创建OutputStreamReader
        FileOutputStream fos=new FileOutputStream("D:\\IOtest\\print2.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
        //读取文件
        int data=0;
        while ((data=fis.read())!=-1){
            System.out.println((char) data);
        }
        //写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱编程\r\n");
            osw.flush();
        }
        //关闭
        isr.close();
        osw.close();
        System.out.println("创建完成");
    }
}

File类

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

• 方法：

  • createNewFile（）//创建一个新文件

  • mkdir()//创建一个新目录

  • delete()//删除文件或空目录

  • exists()//判断File对象所对象所代表的对象是否存在

  • getAbsolutePath()//获取文件的绝对路径

  • getName()//取的名字

  • getParent()//获取文件/目录所在的目录

  • isDirectory()//是否是目录

  • isFile()//是否是文件

  • length()//获得文件的长度

  • listFiles()//列出目录中的所有内容

  • renameTo()//修改文件名为

package com.IO;
​
import java.io.File;
import java.util.Date;
​
/**
 * File类的使用
 *（1）分隔符
 *（2）文件操作
 *（3）文件夹操作
 */
public class Demo15 {
    public static void main(String[] args)throws Exception {
        //separator();
       //filrOpe();
        directoryOpe();
    }
    //（1）分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+ File.separator);
    }
    //（2）文件操作
    public static void filrOpe()throws Exception{
        //1.创建文件
        File file = new File("D:\\file.txt");
        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("文件创建时间"+file.lastModified());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
    //(3)文件夹操作
    public static void directoryOpe()throws Exception{
        //创建文件夹
        File dir=new File("d:\\IOtest\\aaa");
        if (!dir.exists()){
            System.out.println("创建结果"+dir.mkdir());
            //dir.mkdirs();//创建多级目录
        }
        //删除文件夹
        //2.1直接删除
        //System.out.println("创建结果"+dir.delete());//只能删除最底层的文件夹，且为空目录
        //2.1使用jvm来删除
        //dir.deleteOnExit();
        //Thread.sleep(5000);
        //获取文件夹信息
        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());
​
        //判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否是隐藏"+dir.isHidden());
        //遍历文件夹
        File dir2=new File("D:\\IOtest");
        String[] files=dir2.list();
        System.out.println("===================");
        for (String string:
             files) {
            System.out.println(string);
        }
    }
}

FileFilter接口

• public interface FileFilter

  • boolean accept(File pathname)

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

System.out.println("=========FileFilter接口==========");

File[] files1=dir2.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().endsWith(".JPG")) {
            return true;
        }
        return false;
    }
});
for (File file:
     files1) {
    System.out.println(file);
}

递归遍历和递归删除

• 递归遍历

public static void listDir(File dir){
    File[] files=dir.listFiles();
    System.out.println(dir.getAbsolutePath());
    if (files!=null&&files.length>0){
        for (File file:files) {
            if (file.isDirectory()){
                listDir(file);
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

• 递归删除

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. 和流有关

package com.IO;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;
​
/**
 * 演示Properties集合的使用
 */
public class Demo16 {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties = new Properties();
        //添加
        properties.setProperty("uesrname","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //遍历
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:
             pronames) {
            System.out.println(pro+"++++++++"+properties.getProperty(pro));
        }
        //和流有关的方法
        //=====list======、
        PrintWriter pw=new PrintWriter("d:\\print.txt");
        properties.list(pw);
        pw.close();
        //==========store方法===========
        FileOutputStream fos=new FileOutputStream("d:\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        //============load方法 加载============
        Properties properties1=new Properties();
        FileInputStream fis=new FileInputStream("d:\\store.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}