IO流与File类

IO流

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

流的分类

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

字节流

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

• InputStream（抽象类）:字节输入流
• OutputStream（抽象类）:字节输出流

字节流的实现类：FileInputStream的使用

 public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，并指定文件路径
        FileInputStream inputStream = new FileInputStream("d:\aaa.txt");
        //2读取文件
        //第一种方法读取文件
        int data=0;
        while ((data=inputStream.read())!=-1){
            System.out.println(data);
        }
        //第二种方法读取文件
       byte[] bytes=new byte[100];
       int count=0;
       while((count=inputStream.read(bytes))!=-1){
           System.out.println(new String(bytes,0,count));
       }
        //3.关闭
        inputStream.close();
        System.out.println("执行完毕");
    }

FileOutputStream的使用

 public static void main(String[] args) throws IOException{
        //1创建文件字节输出流
        //如果为false，则直接覆盖该文件上的内容，如果为true，则在文件内容的后面追加添加的字节。
        FileOutputStream outputStream = new FileOutputStream("d:\bbb.txt",true);
        //2写入文件
        //单个字节的写入
        outputStream.write(97);
        outputStream.write('b');
        outputStream.write('e');
        outputStream.write('q');
       //多个字节的写入
        String s="hello io";
        outputStream.write(s.getBytes());
        //关闭
        outputStream.close();
        System.out.println("执行完毕");
    }

字节流文件的复制：(可以复制图片，以及二进制文件)

public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\aaa.txt");
        FileOutputStream fo=new FileOutputStream("d:\ccc.txt");
        byte[] bytes=new byte[1024];
        int count=0;
        while ((count=fi.read(bytes))!=-1){
            fo.write(bytes,0,count);
        }
        fi.close();
        fo.close();
    }

字节缓冲流

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

BufferedInputStream和BufferedOutputStream的使用

 public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\aaa.txt");
        //创建字节缓冲流,bi作为缓冲区
        BufferedInputStream bi = new BufferedInputStream(fi);
        int data=0;
        while((data=bi.read())!=-1){
            System.out.print((char)data);
        }
        bi.close();
    }
------------------------------------------------------------------
public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("d:\ccc.txt");
        BufferedOutputStream bo = new BufferedOutputStream(fo);
        for (int i=0;i<10;i++){
            bo.write("hello
".getBytes());
            bo.flush();   //将缓冲区内容刷新到磁盘中
        }
        bo.close();    //直接调用close时，同样将内容刷新到磁盘中了
    }

对象流：ObjectOutputStream/ObjectInputStream

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

 public static void main(String[] args) throws Exception {
        //1创建对象流
        FileOutputStream fo = new FileOutputStream("d:\ddd.txt");
        ObjectOutputStream oo = new ObjectOutputStream(fo);
        //写入对象(序列化)
        Student student = new Student("张三",18);
        oo.writeObject(student);
        //3.关闭
        oo.close();
        System.out.println("序列化完成");
    }

 public static void main(String[] args) throws Exception {
        //1创建对象流
        FileInputStream fi = new FileInputStream("d:\ddd.txt");
        ObjectInputStream oi = new ObjectInputStream(fi);
        //2读取文件（反序列化）
        Student student=(Student)oi.readObject();
        //3关闭
        oi.close();
        System.out.println("反序列化");
        System.out.println(student);
    }

注意点：

• 序列化的类必须实现Serializable接口。
• 序列化类中对象属性要求实现Serializable接口。
• 序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类。
• 使用transient修饰类属性，则这个属性不能被序列化了。
• 静态属性不能被序列化。
• 序列化多个对象，可以借助集合实现。

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

• Reader:字符输入流（抽象类）
• Writer:字符输出流（抽象类）

文件字符流

• FileReader
• FileWriter

文件字符流的复制（只能复制文本文件,不能复制图片，以及二进制文件）

图片是二进制文件，没有字符编码。不能使用字符流复制。

 public static void main(String[] args) throws Exception {
        //1创建字符流的输入、输出
        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();
    }

字符缓冲流BufferedReaderBufferedWriter

• 高效读写
• 支持输入换行符
• 可一次写一行，读一行

打印流PrintWriter

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

转换流 InputStreamReaderOutputStreamWriter

• 可将字节流转换为字符流
• 可设置字符的编码方式

public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\write.txt");
        InputStreamReader is = new InputStreamReader(fi, "utf-8");  //可设置编码方式
        int data=0;
        while((data=is.read())!=-1){
            System.out.print((char)data);
        }
        is.close();
    }
 public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("d:\write2.txt");
        OutputStreamWriter ow = new OutputStreamWriter(fo, "utf-8");//可设置编码方式
        for (int i=0;i<10;i++){
            ow.write("好好学习，天天向上
");
            ow.flush();
        }
        ow.close();
    }

File类

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

调用路径分隔符; File.pathSeparator

调用名称分隔符 File.separator

 //文件操作
public static void main(String[] args) throws IOException, InterruptedException {
       // separator();
        file();
    }
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    public static void file() throws IOException, InterruptedException {
        //创建文件
        File file = new File("d:\file.txt");
        //System.out.println(file.toString());
        //判断文件是否存在
        if (!file.exists()){
            boolean newFile = file.createNewFile();
            System.out.println("创建结果为"+newFile);
        }
      //1直接删除
      //  System.out.println("删除结果为"+file.delete());
        //2使用JVM退出的时候删除
     //   file.deleteOnExit();
     //   Thread.sleep(5000);
        //获取文件信息
        System.out.println("获取绝对路径"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取父目录"+file.getParent());
        System.out.println("获取文件长度"+file.length());
        System.out.println("获取文件生成时间"+new Date(file.lastModified()).toLocaleString());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }

//文件夹操作
public static void dir(){
        //创建文件夹
        File dir = new File("d:\aaa\bbb");
        if (!dir.exists()){
           // dir.mkdir();  只能生成单级目录
            System.out.println("创建结果"+dir.mkdirs());
        }
        //删除文件夹
        //dir.delete();   （只能删除空目录）
        //dir.deleteOnExit();
        //获取文件信息
        System.out.println("获取绝对路径"+dir.getAbsolutePath());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取父目录"+dir.getParent());
        System.out.println("获取文件夹长度"+dir.length());
        System.out.println("获取文件夹生成时间"+new Date(dir.lastModified()).toLocaleString());
        //判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否隐藏"+dir.isHidden());
    //获取文件夹中的所有内容
        String[] list = dir.list();
        for (String s : list) {
            System.out.println(s);
        }
    }

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

  //FileFilter接口的使用，过滤一些文件
          File[] files = dir.listFiles(new FileFilter() {
              public boolean accept(File pathname) {
                  if (pathname.getName().endsWith(".jpg")){
                      return true;
                  }
                  return false;
              }
          });
          for (File file : files) {
              System.out.println(file);
          }
      }
  

  递归遍历文件夹，递归删除文件夹

  public static void main(String[] args) {
         // listDir(new File("d:\aaa"));
          deletedIR(new File("d:\aaa"));
      }
      //递归遍历文件夹
      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()){  //如果file是文件夹，则进行递归。
                      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());
      }