public static void SequenceDemo() throws IOException {
  List<FileInputStream> list = new ArrayList<FileInputStream>();
  list.add(new FileInputStream( new File("temp\\partfiles\\char1.txt" )));
  list.add(new FileInputStream( new File("temp\\partfiles\\char2.txt" )));
  list.add(new FileInputStream( new File("temp\\partfiles\\char3.txt" )));
  SequenceInputStream sis = new SequenceInputStream(Collections.enumeration( list));
  BufferedReader br = new BufferedReader( new InputStreamReader(sis));
  String str = null;
  while (( str = br. readLine()) != null) {
    System.out.println( str);
  }
  br.close();
}

public static void printWrite() throws IOException {
  BufferedReader br = new BufferedReader( new FileReader("temp\\char.txt" ));
  PrintStream ps = new PrintStream(System.out, true );
  String line = null;
  while (( line = br.readLine()) != null) {
    ps.println(line.toUpperCase());
  }
  br.close();
}

package io;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class KeyPrintDemo {
 
  public static void main(String[] args) throws IOException {
    // 需求：读取键盘上录入的字符，显示并以 utf-8编码保存成文件
    BufferedReader br = new BufferedReader( new InputStreamReader(System.in ));
    BufferedWriter bw =
        new BufferedWriter( new OutputStreamWriter( new FileOutputStream("temp\\key.txt" ), "utf-8" ));
    String str = null;
    while (( str = br.readLine()) != null) {
      if ("exit".equals( str)) {
        break;
      }
      System.out.println( str);
      bw.write(str);
      bw.newLine();
      bw.flush();
    }
    bw.close();
  }
}

package bean;
 
public class Employee extends Person {
 
  private static final long serialVersionUID = 201411261L;
 
  /*
   * transient： 瞬态，被该修饰符修饰的变量将不被序列化。同样地，静态变量也不被序列化。
   */
  private transient int salary ;
 
  public Employee(String name, int age, int salary) {
    super(name, age);
    this.salary = salary;
  }
 
  public Employee() {
    super();
  }
 
  public int getSalary() {
    return salary;
  }
 
  public void setSalary( int salary) {
    this.salary = salary;
  }
 
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = super.hashCode();
    result = prime * result + salary;
    return result;
  }
 
  @Override
  public boolean equals(Object obj ) {
    if (this == obj) return true ;
    if (!super.equals( obj)) return false ;
    if (getClass() != obj.getClass()) return false ;
    Employee other = (Employee) obj;
    if (salary != other.salary) return false;
    return true;
  }
 
  @Override
  public String toString() {
 
    return "Employee [Name=" + getName() + ", Age=" + getAge() + ", Salary=" + salary + "]" ;
  }
 
  public static void staticPrint() {
    System.out.println( "Static print run!");
  }
}

public static Object objectRead() throws IOException, ClassNotFoundException {
  ObjectInputStream ois = new ObjectInputStream( new FileInputStream("temp\\os.txt" ));
  Object obj = ois.readObject();
  ois.close();
  return obj;
}
 
public static void objectWrite() throws IOException {
  Employee employee = new Employee( "Java", 25, 25000);
  ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream("temp\\os.txt" ));
  oos.writeObject( employee);
  oos.close();
}

public static int dataRead() throws IOException {
  DataInputStream dis = new DataInputStream( new FileInputStream("temp\\data.txt" ));
  int num = dis.readInt();
  dis.close();
  return num;
}
 
public static void dataWrite() throws IOException {
  DataOutputStream dos = new DataOutputStream( new FileOutputStream("temp\\data.txt" ));
  dos.writeInt(97);   // 写入4字节：00000000 00000000 00000000 01100001
  dos.write(97);  // 写入1字节
  dos.close();
}

• 将内置数组数据输出到一个流中
  void  writeTo(OutputStream out)
• 将内置数组数据输出到一个数组中
  byte[]  toByteArray()
  
• 缓冲区大小
  int  size()
• String  toString()
  String  toString(String charsetName)

private static byte[] byteArray(byte[] b) {
  ByteArrayInputStream bis = new ByteArrayInputStream(b);
  ByteArrayOutputStream bos = new ByteArrayOutputStream(); // 内部有一个可自动增长的数组。
 
  int ch = 0;
  while(( ch= bis.read())!=-1){
      bos.write(ch);
  }
  //因为没有调用底层资源，所以不要关闭，即使调用了close，也没有任何效果，不会抛出IOException。
  return bos.toByteArray();
}

public static void readFile() throws IOException {
  RandomAccessFile raf = new RandomAccessFile("temp\\random.txt" , "r" );
  raf.seek(4);
  int i = raf.readInt();
  System.out.println( i);
  raf.close();
}
 
public static void writeFile() throws IOException {
  RandomAccessFile raf = new RandomAccessFile("temp\\random.txt" , "rw" );
  raf.seek(4);
  raf.writeInt(102);
  System.out.println( raf.getFilePointer());
  raf.close();
}

package io;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
 
/**
 * 使用配置文件的方法分割合并文件
 */
public class TSplitJoinByConfig {
 
  private static final int BUFFER_SIZE = 4096;
 
  /**
   * 以配置文件的方法分割文件
   * @param srcFile  需要分割的文件
   * @param destPath  分割文件的保存目录
   * @param len  分割文件的大小
   * @throws IOException
   */
  public void split(File srcFile, File destPath, long len) throws IOException {
    // 健壮性判断，源文件目的目录是否存在
    if (!srcFile.exists() || srcFile.isDirectory()) {
      throw new RuntimeException( "源文件不存在！" );
    }
    if (len <= 1024) {
      throw new RuntimeException( "分卷大小设置太小或错误！" );
    }
    if (!destPath.exists() || destPath.isFile()) {
      destPath.mkdirs();
    }
    // 定义缓冲区
    byte[] buf = new byte[ BUFFER_SIZE];
    // 定义分割文件序号
    int num = 0;
    // 定义缓冲区数据大小
    int bufLen = 0;
    // 定义单个分割文件剩余的写入字节数
    long splitLen = len;
    // 源文件名
    String fileName = srcFile.getName();
   
    FileInputStream fis = new FileInputStream( srcFile);
    FileOutputStream fos = null;
 
    while ( bufLen != -1) {
      // 单趟外层循环完成一个分割文件的写入
      splitLen = len;
      // 创建输出流，确定分割文件名
      fos = new FileOutputStream( new File( destPath, fileName + ".part" + String.format( "%02d", ++num )));
      while ( splitLen > 0) {
        // splitLen为该单个文件剩余的写入字节数，以此为依据来从输入流读取数据到缓冲区
        if ( splitLen >= BUFFER_SIZE) {
          bufLen = fis.read( buf);
        } else {
          bufLen = fis.read( buf, 0, ( int) splitLen);
        }
        if ( bufLen == -1) {
          break;
        }
        fos.write( buf, 0, bufLen);
        splitLen -= ( long) bufLen;
      }
      fos.close();
    }
    fis.close();
   
    // 将文件名和分割文件数写入配置文件
    Properties prop = new Properties();
    prop.setProperty( "FileName", srcFile .getName());
    prop.setProperty( "PartNo.", String.valueOf( num));
    FileWriter fw = new FileWriter( new File( destPath, srcFile.getName() + ".properties" ));
    prop.store(fw, "Split File Config");
    fw.close();
  }
 
  public void join(File splitFirFile) throws IOException {
    // 健壮性判断
    if (!splitFirFile.exists() || splitFirFile.isDirectory()) {
      throw new RuntimeException( "分割文件不存在！" );
    }
    // 分割文件名（不包括扩展名）
    String splitFileName = splitFirFile.getName().substring(0, splitFirFile.getName().length() - 7);
    // 分割文件目录
    File splitFilePath = splitFirFile.getParentFile();
    // 配置文件
    File propFile = new File( splitFilePath, splitFileName + ".properties");
    if (!propFile.exists() || propFile.isDirectory()) {
      throw new RuntimeException( "配置文件不存在！" );
    }
    // 读取配置文件
    Properties prop = new Properties();
    FileReader fr = new FileReader( propFile);
    prop.load(fr);
    fr.close();
    // 合并文件名
    String fileName = prop.getProperty( "FileName");
    int num = Integer.parseInt(prop.getProperty( "PartNo."));
    // 判断分割文件是否完整
    File[] splitFiles = new File[ num];
    for (int i = 1; i <= num; i++) {
      splitFiles[i - 1] = new File( splitFilePath, splitFileName + ".part" + String.format( "%02d", i ));
      if (!splitFiles[i - 1].exists() || splitFiles[ i - 1].isDirectory()) {
        throw new RuntimeException( "缺少分割文件：" + splitFiles[i - 1].getName());
      }
    }
   
    // 将流加入集合，并使用序列输入流完成合并
    List<FileInputStream> list = new ArrayList<FileInputStream>();
    for (int i = 1; i <= num; i++) {
      list.add(new FileInputStream( splitFiles[ i - 1]));
    }
    byte[] buf = new byte[ BUFFER_SIZE];
    int len = -1;
    SequenceInputStream sis = new SequenceInputStream(Collections.enumeration( list));
    FileOutputStream fos = new FileOutputStream( new File(splitFilePath, fileName ));
    while (( len = sis.read( buf)) != -1) {
      fos.write(buf, 0, len);
    }
    fos.close();
    sis.close();
  }
}

package io;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class TSplitJoin {
 
  private static final int BUFFER_SIZE = 4096;
  private static final long PROPERTIES_SIZE = 1024;
 
  /**
   * 分割文件，必要信息存储到第一个文件中
   * @param srcFile  需要分割的文件
   * @param destPath  分割文件的保存目录
   * @param len  分割文件的大小
   * @throws IOException
   */
  public void split(File srcFile, File destPath, long len) throws IOException {
    // 健壮性判断，源文件目的目录是否存在
    if (!srcFile.exists() || srcFile.isDirectory()) {
      throw new RuntimeException( "源文件不存在！" );
    }
    if (len <= 4096) {
      throw new RuntimeException( "分卷大小设置太小或者错误！" );
    }
    if (!destPath.exists() || destPath.isFile()) {
      destPath.mkdirs();
    }
    // 定义缓冲区
    byte[] buf = new byte[ BUFFER_SIZE];
    // 定义分割文件序号
    int num = 0;
    // 定义写入缓冲区数据大小
    int bufLen = 0;
    // 定义单个分割文件剩余的写入字节数
    long splitLen = len - PROPERTIES_SIZE;
    // 源文件名
    String fileName = srcFile.getName();
   
    FileInputStream fis = new FileInputStream( srcFile);
    FileOutputStream fos = new FileOutputStream( new File(destPath, fileName + ".part01" ));
    String content = fileName + "\n" + (int)Math.ceil(( double)srcFile .length() / (double) len) + "\n";
    System.arraycopy(content .getBytes("utf-8" ), 0, buf , 0, content.getBytes().length );
    fos.write(buf, 0, (int)PROPERTIES_SIZE);
 
    while ( bufLen != -1) {
      // 单趟外层循环完成一个分割文件的写入
      // 创建输出流，确定分割文件名
      if (num != 0) {
        fos = new FileOutputStream( new File( destPath, fileName + ".part" + String.format( "%02d", ++num )));
      } else {
        num++;
      }
      while ( splitLen > 0) {
        // splitLen为该单个文件剩余的写入字节数，以此为依据来从输入流读取数据到缓冲区
        if ( splitLen >= BUFFER_SIZE) {
          bufLen = fis.read( buf);
        } else {
          bufLen = fis.read( buf, 0, ( int) splitLen);
        }
        if ( bufLen == -1) {
          break;
        }
        fos.write( buf, 0, bufLen);
        splitLen -= ( long) bufLen;
      }
      fos.close();
      splitLen = len;
    }
    fis.close();
  }
 
  public void join(File splitFirFile) throws IOException {
    // 健壮性判断
    if (!splitFirFile.exists() || splitFirFile.isDirectory()) {
      throw new RuntimeException( "分割文件不存在！" );
    }
    // 分割文件名（不包括扩展名）
    String splitFileName = splitFirFile.getName().substring(0, splitFirFile.getName().length() - 7);
    // 分割文件目录
    File splitFilePath = splitFirFile.getParentFile();
 
    // 读取配置信息
    byte[] buf = new byte[ BUFFER_SIZE];
    FileInputStream fis = new FileInputStream(splitFirFile );
    fis.read(buf, 0, (int)PROPERTIES_SIZE);
    fis.close();
    String[] prop = new String( buf, "utf-8").split("\n" );
    String fileName = prop[0];
    int num = Integer.parseInt(prop [1]);
   
    // 判断分割文件是否完整
    File[] splitFiles = new File[ num];
    for (int i = 1; i <= num; i++) {
      splitFiles[i - 1] = new File( splitFilePath, splitFileName + ".part" + String.format( "%02d", i ));
      if (!splitFiles[i - 1].exists() || splitFiles[ i - 1].isDirectory()) {
        throw new RuntimeException( "缺少分割文件：" + splitFiles[i - 1].getName());
      }
    }
   
    // 将流加入集合，并使用序列输入流完成合并
    List<FileInputStream> list = new ArrayList<FileInputStream>();
    for (int i = 1; i <= num; i++) {
      list.add(new FileInputStream( splitFiles[ i - 1]));
    }
    int len = -1;
    SequenceInputStream sis = new SequenceInputStream(Collections.enumeration( list));
    FileOutputStream fos = new FileOutputStream( new File(splitFilePath, fileName ));
    sis.skip(PROPERTIES_SIZE);
    while (( len = sis.read( buf)) != -1) {
      fos.write(buf, 0, len);
    }
    fos.close();
    sis.close();
  }
}

• SequenceInputStream是字节流的包装类，能够提供多个流序列输入功能。
• 序列流只有输入流，适合完成多个源一个目的的需求。
• SequenceInputStream支持枚举输入，若源的数量大于2个，那么需要先建立枚举再通过构造器创建序列输入流。
• SequenceInputStream的使用和其他流基本类似。
• SequenceInputStream本质属于字节流。

2. 构造器

• SequenceInputStream(Enumeration<? extends InputStream> e)
• SequenceInputStream(InputStream s1, InputStream s2)

3. 常用方法

• int  available()
• void  close()
• int  read()
• int  read(byte[] b, int off, int len)

• PrintStream/PrintWriter能够输出多种数据类型的表现形式，多用于基本数据的打印格式化字符串输出。
• PrintStream/PrintWriter的目标可以是文件和所有的输出流。
• PrintStream/PrintWriter永远不会抛出IOException，只能通过调用checkError()检查是否出现错误。
• PrintStream可以实现换行符自动刷新，PrintWriter仅在调用println、printf或format方法时才可以实现自动刷新。
• PrintStream保留了原始字节流的输出方式，而PrintWriter仅限于带编码的字符数据。
• PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
• System.out类型即为PrintStream。

2. 构造器

• PrintStream：
  PrintStream(File file)
  PrintStream(File file, String csn)
  PrintStream(OutputStream out)
  PrintStream(OutputStream out, boolean autoFlush)
  PrintStream(OutputStream out, boolean autoFlush, String encoding)
  PrintStream(String fileName)
  PrintStream(String fileName, String csn)
• PrintWriter：
  PrintWriter(File file)
  PrintWriter(File file, String csn)
  PrintWriter(OutputStream out)
  PrintWriter(OutputStream out, boolean autoFlush)
  PrintWriter(String fileName)
  PrintWriter(String fileName, String csn)
  PrintWriter(Writer out)
  PrintWriter(Writer out, boolean autoFlush)

3. 常用方法

• PrintStream  append(...)
• boolean  checkError()
• protected void  clearError()
• void  close()
• void  flush()
• PrintStream  format(String format, Object... args)
• void  print(...)
• PrintStream  printf(String format, Object... args)
• void  println(...)
• protected void  setError()
• void  write(...)
  

4. 示例

• Java中内置了标准输入输出流，以静态域的形式提供在System类中。
• 标准输入流System.in默认为键盘，标准输出流System.out默认为控制台。
• 标准输入流为字节流InputStream类型，标准输出流为打印流PrintStream类型。
• 标准输入输出流可以被其他流装饰类包装，以实现更多功能。
• 标准输入输出流不需要关流。

2. 示例

• 目标是字节流。
• 将基本数据或对象转化为数据流的过程被称之为序列化，而反序列化就是相反的过程。
• ObjectInputStream/ObjectOutputStream的作用就是基本数据类型或对象的序列化和反序列化。
• ObjectInputStream确保从流创建的图形中所有对象的类型与Java虚拟机中显示的类相匹配。
• 只有实现了java.io.Serializable或java.io.Externalizable接口的对象才能被序列化或反序列化。
• 在Java中，字符串和数组都是对象，所以在序列化期间将其视为对象，读取时，需要将其强制转换为期望的类型。
• 序列化和反序列化进程将忽略声明为瞬态或静态的字段。
• readObject()及其他非父类读取方法的读取是无法判断文件末尾的，所以需要确定读取次数，以免出现EOFException。

2. 序列化接口Serializable

• Serializable没有方法，不需要覆盖，是一个标记接口。
• Serializable启动一个序列化功能，给每一个需要序列化的类都分配一个序列版本号。
• 实现了Serializable的类需要定义序列版本号serialVersionUID，该号和该类相关联。
• serialVersionUID用于序列化过程中的验证。在序列化时，会将这个序列号也一同保存到文件中。
  在反序列化会读取这个序列化和本类的序列化进行匹配，如果不匹配会抛出异常：java.io.InvalidClassException
• 强烈建议：显式声明serialVersionUID，因为默认serialVersionUID的计算是对类的细节高度敏感的，所以可能会有不同平台
  计算默认的的serialVersionUID值有所不同的情况出现，可能就会发生不可预期的InvalidClassExceptions异常。
• 强烈建议：使用private关键字修饰声明serialVersionUID，因为serialVersionUID只对当前类有效，对子类是毫无意义的。

3. 构造器

• ObjectInputStream()
• ObjectInputStream(InputStream in)
• ObjectOutputStream()
• ObjectOutputStream(OutputStream out)

• ObjectInputStream：
  boolean  readBoolean()
  byte  readByte()
  char  readChar()
  double  readDouble()
  float  readFloat()
  void  readFully(byte[] buf)
  void  readFully(byte[] buf, int off, int len)
  int  readInt()
  long  readLong()
  Object  readObject()
  short  readShort()
• ObjectOutputStream：
  void  write(byte[] buf)
  void  write(byte[] buf, int off, int len)
  void  writeBoolean(boolean val)
  void  writeByte(int val)
  void  writeBytes(String str)
  void  writeChar(int val)
  void  writeChars(String str)
  void  writeDouble(double val)
  void  writeFields()
  void  writeFloat(float val)
  void  writeInt(int val)
  void  writeLong(long val)
  void  writeObject(Object obj)
  void  writeShort(int val)

• 目标为字节流。
• 用于基本数据的内存原始数据的输入输出。
• 该类特有的数据读取方法无法检测流的末尾，所以需要确定读取次数，以免出现EOFException异常。

• 目标为内存数组，本质为字节流。
• 该流是为了按流的方式处理数据，某些情况下将会更加方便。
• 由于没有调用底层资源，所以该流不需要关闭。
• 创建ByteArrayInputStream流对象时需要将字节数组作为数据源参数传入，而ByteArrayOutputStream流对象中维护了一个大数组用于存储数据。
• 该流的方法与其他流类似，ByteArrayOutputStream流使用toByteArray()方法返回保存数据的数组。

2. 特有方法

3. 示例

• 目标为文件，可以实现字节流字符流的读写。
• 提供了文件指针，可以进行随机读写，就类似存储在文件系统中的一个大型 byte 数组。
• 创建对象时可选模式："r"只读, "rw"读写, "rws"读写并将更新的内容和元数据同步到设备, 或者"rwd"读写并将更新的内容同步到设备。

2. "rw", "rws", "rwd" 的区别

• 当操作的文件是存储在本地的基础存储设备上时(如硬盘, NandFlash等)，"rws" 或 "rwd", "rw" 才有区别。
• 当模式是 "rws" 并且操作的是基础存储设备上的文件；那么，每次“更改文件内容[如write()写入数据]” 或 “修改文件元数据(如文件的mtime)”时，都会将这些改变同步到基础存储设备上。
• 当模式是 "rwd" 并且操作的是基础存储设备上的文件；那么，每次“更改文件内容[如write()写入数据]”时，都会将这些改变同步到基础存储设备上。
• 当模式是 "rw" 并且操作的是基础存储设备上的文件；那么，关闭文件时，会将“文件内容的修改”同步到基础存储设备上。至于，“更改文件内容”时，是否会立即同步，取决于系统底层实现。

• RandomAccessFile(File file, String mode)
• RandomAccessFile(String name, String mode)

• void  close()
• 获取文件指针
  long  getFilePointer()
• 获取文件长度
  long  length()
• int  read()
  int  read(byte[] b)
  int  read(byte[] b, int off, int len)
  boolean  readBoolean()
  byte  readByte()
  char  readChar()
  double  readDouble()
  float  readFloat()
  void  readFully(byte[] b)
  void  readFully(byte[] b, int off, int len)
  int  readInt()
  String  readLine()
  long  readLong()
  short  readShort()
  int  readUnsignedByte()
  int  readUnsignedShort()
  String  readUTF()
• 设置文件指针
  void  seek(long pos)
• 设置文件长度
  void  setLength(long newLength)
• 跳过字节数
  int  skipBytes(int n)
• void  write(byte[] b)
  void  write(byte[] b, int off, int len)
  void  write(int b)
  void  writeBoolean(boolean v)
  void  writeByte(int v)
  void  writeBytes(String s)
  void  writeChar(int v)
  void  writeChars(String s)
  void  writeDouble(double v)
  void  writeFloat(float v)
  void  writeInt(int v)
  void  writeLong(long v)
  void  writeShort(int v)
  void  writeUTF(String str)