Java - I/O

File类

•  java.io

　操作文件和目录，与平台无关。具体的常用实例方法：

File file = new File(".");    //  以当前路径创建名为 "." 的 File 对象

  ·   文件目录信息函数
    -   String getName/Path/Parent()： 文件名/路径/父目录
    -   boolean renameTo(File newName)：文件/目录重命名
    -   long length()：文件内容长度
    -   long lastModified()：文件最后编辑时间
  ·   文件检测函数
    -   boolean exists()：判断文件/目录是否存在
    -   boolean isFile/isDirectory()：判断是否为文件/目录
    -   boolean canRead/Write()：是否可读/写
    -   boolean isAbsolute()：文件/目录是否绝对路径
  ·   文件目录操作函数
    -   boolean creatNewFile()：新建 File 对象对应的文件
    -   boolean mkdir()：创建 File 对象对应的目录
    -   boolean delete()：删除文件/目录
    -   void deleteOnExit()：JVM 退出时，删除文件/目录
    -   String[] list()：返回 File 对象的所有子文件名和路径名
    -   File[] listFiles()：返回 File 对象的所有子文件和路径

  ·   文件过滤器
　利用File类的String[] list(FilenameFilter filter)方法，过滤得到指定类型的文件/目录，必须重写accept方法。具体应用步骤：
  ζ   实现FilenameFilter接口；
  ζ   实现boolean accept(File dir, String name)方法； 　
由于FilenameFilter是函数式接口，Lambda表达式可直接作为入参。
 参考 ：FilenameFilter 介绍；

  ·   RandomAccessFile类
　  Java输入-输出体系中功能最丰富的文件内容访问类(局限性是只能读写文件，不能读写IO流)，提供"随机访问"方式，支持追加文件内容、自由定义记录指针位置：
　  -  long getFilePointer()：返回文件记录指针当前位置；
　  -  void seek(long pos)：文件记录指针定位到pos处；
注意，定点插入数据需要先缓存插入点之后的数据，然后追加新数据，最后还原缓存的数据。RandomAccessFile类可以实现多线程断点下载/传输工具。

Files类

•  java.io.file

　File类的工具类，高度封装，支持文件复制、读写文件、遍历文件和子目录，Java-8支持Stream API操作文件目录和文件内容。

 ·   文件复制

Files.copy(Path source, Path target, CopyOption options);  // 文件到文件
Files.copy(InputStream in, Path target, CopyOption options);   // 输入流到文件
Files.copy(Path source, OutputStream out);   // 文件到输出流

 ·   读写文件

Files.write(Path src, List<string> strList);  // 将字符串内容写入文件
Files.list(Path path);  // 列出path目录下的所有文件和子目录
Files.lines(Path src);  // 列出文件中所有行

 ·   遍历文件和目录

// 遍历startPath路径下所有文件和子目录，并会“触发”FileVisitor中的相应方法
Files.walkFileTree(Path startPath, FileVisitor<? super Path> visitor);
Files.walkFileTree(Path startPath, Set<File VisitOption> options, int maxDepth, FileVisitor<? super Path> visitor);　　

I/O 流

　流(stream)是从起源(source)到接收(sink)的有序数据，允许Java程序以相同的方式访问不同的输入/输出源。Java通过装饰器模式将底层节点流(低级流)封装成上层处理流(高级流)，统一对不同数据源的访问，灵活方便、执行效率高。利用文件过滤器和I/O流可以实现文件的条件复制。流模型的功能体现：
  ·　性能提高：以增加缓冲的方式提高I/O效率；
  ·　操作便捷：提供不同的流处理方法，灵活性；　
　Java-I/O的4个抽象基类：
  ·   输入流： InputStream，字节流 - Reader，字符流，
  ζ  int read()：读取单字节/单字符，返回int型字节/字符数据；
  ζ  int read(byte/char[] b)： 字节/字符数组；
  ζ  int read(byte/char[] b, int pos, int len)：字节/字符数组；
  ·   输出流：OutputStream，字节流 - Writer，字符流
  ζ  void write(int v)：将字节/字符数据v写入到输出流中；
  ζ  int write(byte/char[] b)-(String str)：字节/字符数组 - 字符串；
  ζ  int write(byte/char[] b, int pos, int len)-(String str, int pos, int len)：字节/字符数组 - 字符串；
　字节流比字符流适应范围广，但字符流操作方便，文本文件推荐字符流，二进制文件推荐字节流。流的处理依靠隐式的记录指针：
   ζ  void mark(int pos)：标记记录指针当前位置；
   ζ  void reset()：记录指针复位；　
   ζ  long skip(long n)：记录指针前移n个字节/字符；
　节点流直接以物理IO节点为构造器参数，处理流以已存在的流为构造器参数。System.out是输出处理流PrintStream的实例，System.in是输入节点流InputStream的实例。
    其他的流
  [1].转换流：InputStreamReader/OutputStreamWriter
　　 处理流，将字节流单向转换为字符流。
  [2].推回输入流：PushbackInputStream/Reader
　　 处理流，利用推回缓冲区，其方法unread()可以重复读取刚刚读取的内容。
  [3].缓冲流：BufferedInput/OutputStream-BufferedReader/Writer
　　 处理流，结合flush()方法实现缓冲功能。其方法readLine()用于读取行。
  [4].对象流：ObjectInput/OutputStream
　　 处理流，实现对象的序列化。
  [5].管道流：PipedInput/OutputStream-PipedReader/Writer
　　 节点流，实现进程间通信。
　 其他的如处理文件、数组、字符串的流均为节点流。
    标准流重定向：将System.in/out重定向到相应位置；
   static void setIn/Out/Err(InputStream in/PrintStream out/PrintStream err)；
 此外，Runtime.getRuntime().exec("文件名")启动子进程，JVM可以利用返回的Process对象读写子进程的数据。

参考：Java - IO整理

对象序列化机制

　允许把内存中的Java对象(对象的类名、实例变量)转换为平台无关的二进制字节流(序列化，Serialize)，用于永久保存对象到磁盘或利用套接字/RMI传输对象，后续可以恢复出Java对象(反序列化，Deserialize)。其中，反序列化读取的是类对象的数据而不是类本身，必须提供该对象的class文件。对象序列化机制是Java提供分布式网络编程的基础，也是Java EE的基础。
　对象支持序列化，其类必须是可序列化的，即必须实现接口之一：
　 · Serializable：标记声明性接口，常用；
　 · Externalizable：用于完全自定义序列化机制，性能略优但编程复杂度高；

public class MyClass implements java.io.Serializable{
      ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("文件名")); 
      MyClass objMy = new MyClass();   out.writeObject(objMy);
      out.close();

      ObjectInputStream in = new ObjectInputStream(new FileInputStream("文件名"));    
      MyClass resMy = (MyClass)in.readObject();
      in.close();
}

　Java序列化机制采用对对象序列化编号的方法避免同一对象重复序列化，此方法中要注意可变对象。
  ·   自定义序列化机制
　 自定义序列化控制程序如何序列化实例变量，重写如下方法：
　　·  private void writeObject(ObjectOutputStream out)：写入特定类的实例状态；
　　·  private void readObject(ObjectInputStream in)：从流中读取并恢复对象的实例变量；
　　·  private void readObjectNoData()：可以正确初始化反序列化的对象；
　 关键字transient用于修饰实例变量，序列化对象时忽略之，static变量也不会序列化，但是可以通过重写writeObject()和readObject()手动序列化保存。

@override
private void writeObject(ObjectOutputStream out) throws IOException{
      out.defaultWriteObject();
      out.writeXxx(基本类型变量)/writeObject(引用类型变量);
}
@override
private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException{
      in.defaultReadObject();
      in.ReadXxx()/readObject();
}

　 自定义序列化机制可以加密提供安全性：　
　　·  private Object writeReplace()
　　　 序列化对象objA时将对象objA替换成其他对象objB，然后调用writeObject()方法序列化对象objB，可继承；
　　·  private Object readResolve()
　　　 实现保护性复制整个对象，在readObject()之后调用，返回值会代替readObject()反序列化出来的对象以保证反序列化的正确性，常用于单例类、枚举类的序列化，可继承；
  ·   完全自定义序列化机制
　允许完全由程序员自主决定存储和恢复对象数据，必须实现接口Externalizable和如下方法：
　 ·  public void writeExternal(ObjectOutput out)：保存对象的状态；
　 ·  public void readExternal(ObjectInput in)：实现对象反序列化；
　 方法实现体中，调用DataIn/Output(ObjectIn/Output的父接口)的方法保存/恢复基本类型的实例变量，调用ObjectIn/Output的read/writeObject()方法保存/恢复引用类型的实例变量。

public class MyClass implements Externalizable{
      public MyClass(){}       // 无参的public构造函数
      @override
      public void writeExternal(ObjectOutput out) throws IOException{
          ...
      }
      @override
      public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException{
          ...
      }
}

  ·   序列化机制版本
　 Java序列化机制允许为序列化类提供private static final long serialVersionUID标识Java类的序列化版本，保证序列化版本的兼容性、有利于程序在不同JVM间的可移植性。

参考：

• Java对象序列化； 理解Java对象序列化； JAVA序列化机制；序列化介绍；
• Java序列化格式详解； 

NIO

Java的NIO参见：Java - NIO - sqh；