java.io.File类

构造方法

// 文件路径名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname); 

// 文件路径名
String pathname2 = "D:\\aaa\\bbb.txt";
File file2 = new File(pathname2); 

// 通过父路径和子路径字符串
 String parent = "d:\\aaa";
 String child = "bbb.txt";
 File file3 = new File(parent, child);

// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file4 = new File(parentDir, child);

获取文件和目录信息

• public String getName() ：返回由此File表示的文件或目录的名称
• public long length() ：返回由此File表示的文件的长度

获取路径

• public String getPath() ：将此File转换为路径名字符串
• public String getParent() ：获得父级路径
• public String getAbsolutePath() ：返回此File的绝对路径名字符串

判断

• public boolean exists() ：此File表示的文件或目录是否实际存在
• public boolean isDirectory() ：此File表示的是否为目录
• public boolean isFile() ：此File表示的是否为文件

创建删除

• public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件
• public boolean delete() ：删除由此File表示的文件或目录。 只能删除空目录
• public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录

目录的遍历

• public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录

• public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录

递归删除非空目录

@Test
public void test6() {
    File dir = new File("D:/atguigu/javase");
    forceDeleteDir(dir);
}
public void forceDeleteDir(File dir) {
    if (dir != null && dir.isDirectory()) {
        File[] listFiles = dir.listFiles();
        if(listFiles!=null){
            for (File sub : listFiles) {
                forceDeleteDir(sub);
            }
        }
    }
    dir.delete();
}

字节流

字节输出流

常用API

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源

• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出

• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流

• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流

• public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件

• public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件

  public class FOSWrite {
      public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
          FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
            // 字符串转换为字节数组
            byte[] b = "abcde".getBytes();
          // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
          fos.write(b);
            // 关闭资源
          fos.close();
      }
  }
  文件操作前：cd
  文件操作后：cdabcde

写出换行

• Windows系统里，每行结尾是 回车+换行 ，即\r\n
• Unix系统里，每行结尾只有 换行 ，即\n
• Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一

字节输入流

常用API

• public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
• public abstract int read()： 从输入流读取数据的下一个字节。
• public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中

使用字节数组读取

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

字符流

字符输入流

使用字符数组读取

public class FISRead {
    public static void main(String[] args) throws IOException {
          // 使用文件名称创建流对象
           FileReader fr = new FileReader("read.txt");
          // 定义变量，保存有效字符个数
        int len ；
        // 定义字符数组，作为装字符数据的容器
        char[] cbuf = new char[2];
        // 循环读取
        while ((len = fr.read(cbuf))!=-1) {
            System.out.println(new String(cbuf,0,len));
        }
        // 关闭资源
        fr.close();
    }
}

字符输出流

关闭和刷新

• flush：刷新缓冲区，流对象可以继续使用
• close：刷新缓冲区，然后通知系统释放资源，流对象不可以再被使用了

写出字符数组

public class FWWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileWriter fw = new FileWriter("fw.txt");     
          // 字符串转换为字节数组
          char[] chars = "博客园".toCharArray();

          // 写出字符数组
          fw.write(chars); // 博客园

        // 写出从索引1开始，2个字节。索引1是'博'，两个字节，也就是'博客'。
        fw.write(b,1,2); // 博客

          // 关闭资源
        fos.close();
    }
}

字节缓冲流

// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

字符缓冲流

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

• BufferedReader：public String readLine(): 读一行文字。
• BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

转换流

指定编码读取

public class ReaderDemo2 {
    public static void main(String[] args) throws IOException {
          // 定义文件路径,文件为gbk编码
        String FileName = "E:\\file_gbk.txt";
          // 创建流对象,默认UTF8编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(FileName));
          // 创建流对象,指定GBK编码
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream(FileName) , "GBK");
        // 定义变量,保存字符
        int read;
          // 使用默认编码字符流读取,乱码
        while ((read = isr.read()) != -1) {
            System.out.print((char)read); // ��Һ�
        }
        isr.close();

          // 使用指定编码字符流读取,正常解析
        while ((read = isr2.read()) != -1) {
            System.out.print((char)read);// 大家好
        }
        isr2.close();
    }
}

转换流图解

序列化

概述

• Java提供了一种对象序列化机制，用一个字节序列可以表示一个对象
• 该字节序列包含该对象的类型和对象中存储的属性等信息
• 字节序列写出文件后，相当于文件中持久保存了一个对象的信息

序列化图解

序列化操作

• 该类必须实现Serializable接口

• 如果某个属性不需要被序列化，则要用transient关键字修饰

  public class Employee implements java.io.Serializable {
      public static String company = "博客园";
      public String name;
      public String address;
      public transient int age; // transient瞬态修饰成员,不会被序列化
      public void addressCheck() {
            System.out.println("Address  check : " + name + " -- " + address);
      }
  }

写出对象

public class SerializeDemo{
       public static void main(String [] args)   {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20; 
        try {
              // 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
       }
}
输出结果：
Serialized data is saved

读取对象

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {        
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
            // 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);    // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

JDK1.7之后引入新try...catch

语法格式

try(需要关闭的资源对象的声明){
    业务逻辑代码
}catch(异常类型 e){
    处理异常代码
}catch(异常类型 e){
    处理异常代码
}
....
//没有finally，也不需要生许愿手动关闭资源对象
//无论是否发生异常，都会关闭资源对象

示例

@Test
public void test03() {
    //从d:/1.txt(GBK)文件中，读取内容，写到项目根目录下1.txt(UTF-8)文件中
    try(
        FileInputStream fis = new FileInputStream("d:/1.txt");
        InputStreamReader isr = new InputStreamReader(fis,"GBK");
        BufferedReader br = new BufferedReader(isr);

        FileOutputStream fos = new FileOutputStream("1.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        BufferedWriter bw = new BufferedWriter(osw);
    ){
        String str;
        while((str = br.readLine()) != null){
            bw.write(str);
            bw.newLine();
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}