File

File类，文件路径，既代表了一个特定文件的名称，有能代表一个目录下的一组文件的名称(list()方法，返回文件名的字符串数组)。

1. 目录过滤器 java.io.FilenameFilter
   过滤器包含有accept()方法，返回一个布尔值，表示是否接受该文件。file.list(filenameFilter)获取符合过滤器的文件名。
2. 目录实用工具

public final class Directory{
  //过滤目录下的文件
  public static File[] local(File dir, final String regex){
    return dir.listFiles(new FilenameFilter(){
      private Pattern pattern = Pattern.compile(regex);
      public boolean accept(File dir, String name){
        return pattern.matcher(new File(name).getName()).matches();
      }
    });
  }
  //重载
  public static File[] local(String path, final String regex){
    return local(new File(path), regex);
  }
}

//
public static class TreeInfo implements Iterable<File>{
  public List<File> files = new ArrayList<File>();
  public List<File> dirs = new ArrayList<File>();
  //默认迭代器是files的迭代器
  public Iterator<File> iterator(){
    return files.iterator();
  }
  
  void addAll(TreeInfo other){
    files.addAll(other.files);
    dirs.addAll(other.dirs);
  }
  
  //walk():递归的查找某个目录下的所有文件
  public static TreeInfo walk(File start, String regex){
      return recurseDirs(start, regex);
  }
  public static TreeInfo walk(File start){
      return recurseDirs(start,".*");
  }
  static TreeInfo recurseDirs(File startDir, String regex){
    TreeInfo result = new TreeInfo();
    for(File item : startDir.listFiles()){
      if(item.isDirectory()){
        result.dirs.add(item);
        result.addAll(recurseDirs(item, regex));
      } else{
         if(item.getName().matches(regex))result.files.add(item);
      }
    }
    return result;
  }
}

File对象有很多作用，还可以创建新的目录和删除文件等等，可以查看api全面了解一下。

输入和输出

输入：自Inputstream或Reader派生而来的类都含有名为read()的基本方法，用于读取单个字节或者字节数组。
输出：自OutputStream或Writer派生而来的类都含有名为write()的基本方法，用于写单个字节或字节数组。
1.InputStream类型
数据源：字节数组、String对象、文件、pipe、由其他种类的流组成的序列，其他数据源，比如Internet连接。不同数据源有相应的子类。

2. OutputStream类型

添加属性和有用的接口

因为Java I/O类库需要多种不同功能的组合，所以需要使用装饰器模式。装饰器必须具有和它所装饰对象相同的接口。FilterXXXX两个输入输出流就是装饰器的必要条件。

1. FIlterInputStream类型（FilterReader）：

2. FilterOutPutStream（FilterWriter抽象类，没有子类）向OutputStream写入

Reader和Writer

Stream面向字节，Reader和Writer面向兼容Unicode的字符I/O，国际化。有时，使用适配器类：InputStreamReader将InputStream转换为Reader，OutputStreamWriter将OutoutStream转换为Writer。一般先用Reader和Writer，不行的话再用stream。

更改流的行为：

自我独立的类：RandomAccessFile

RandomAccessFile继承了DataInput、DataOutput这两个接口，提供的对文件内容的访问，它既可以读文件，也可以写文件，并且RandomAccessFile支持随机访问文件，可以指定位置进行访问。
与File的区别最根本的是在Java中Class File代表的是“文件/目录”本身，可以想象成是一个文件句柄、标识，这个类本身只提供对文件的打开，关闭，删除，属性访问等等；而RandomAccessFile类则是文件访问的类，从类名可以看出它是一种文件访问方法：随机访问文件。这样就很好理解，比如在vi或者notepad中你的光标随意游走，改变一些内容，然后保存，关闭等等，这些是它的功能。
作用：
1.断点续传；2.RandomAccessFile可以提高读取的速度。根据文件的hashcode生成一个位置存入文件，取得时候再反过来根据这个固定的位置直接就能找到文件。
jdk1.4中大多数功能被nio存储映射取代。

I/O流的使用方式

1. 缓冲输入文件

public class BufferedInputFile{

public static String read(String filename) throws IOException{
  //reading input by lines
  BufferedReader in = new BufferedReader(new FileReader(filename));
  String s;
  StringBuffer sb = new StringBuffer();
  while((s = in.readLine() ) != null){
    sb.append(s + "\n");
  }
  in.close();
  return sb.toString();
}

}

2. 从内存输入
   用上面的BufferedInputFile.read()读入的String结果被用来创建一个StringReader。然后调用read()每次读入一个字符，发送至控制台

public static String read(String filename) throws IOException{
  StringReader in=new StringReader(BufferedInputFile(filename));
  int c;
  while((c=in.read())!= -1){
      System.put.print((char) c);
  }
}

3. 格式化内存输入
   要读取格式化数据，可以使用DataInputStream。

public static void main throws IOException{
  try{
    DataInputStream in = new DataInputStream( 
      new ByteArrayInputStream( //必须为ByteArrayInputStream提供字节数组
      new BufferedInputFile("xxxx.java").getBytes()));
    while(true)
      print((char)in.readByte());
   } catch(EOFException e){//一个IO异常的子类，名字也是END OF FILE的缩写，表示流的末尾
      print("End of Stream");
   }
}

使用DataInputStream用readByte()读取字节，任何字节都是合法结果，返回值不能用来检测输入是否结束。可以使用available()查看还有多少可供存取的字符。注意，available()会随着所读取的媒介类型不同而不同，字面意思是没有阻塞的情况下所能读取的字节数，对于文件，可能意味着整个文件，对其他可能不同。

public static void main throws IOException{
  DataInputStream in = new DataInputStream(
    new BufferedInputStream(
      new FileInputStream("xxx.java")));
  while(in.available() != 0)
    print((char)in.readByte());
}

4. 基本文件输出
   FileWriter可以向文件写入数据，为了提供格式化机制，被装饰城PrintWriter。这种方式创建的文件可作为普通文本文件读取。

public static void main throws IOException{
  BufferReader in = new BufferReader(
    new StringReader(
      BufferedInputFile.read("xxx.java")));
  PrintWriter out = new PrintWriter(
    new BufferedWriter( new FileWriter("xxxx.out")));
  //PrintWriter添加了辅助构造器，可以直接创建文本，并缓冲写入
  // PrintWriter out = new PrinterWriter("xxxx.out");
  int lineCount = 1;
  String s;
  while((s = in.readLine() )!= null)
    out.println(lineCount++ + ": " + s);
  out.close();

  //显示存入的文件
  print(new BufferedInputFile("xxxx.out"));
}

5. 存储和恢复数据
   当使用DataOutputStream写入数据，java保证可以使用DataInputStream准确读取数据。做法就是使用UTF-8编码，writeUTF()和readUTF()。java使用的是UTF-8辩题，非java程序读取需要编写一些特殊代码才能读取字符串。但如果用writeDouble()将double类型写入流，需要用readDouble()恢复。但可能被作为其他类型读入。因此，要么为文件中的数据采用固定的格式，要么将额外信息保存如文件中，以便能够解析以确定数据的存放文职。因此，对象序列化和XML可能是更容易的存储和读取复杂数据结构的方式。

public static void main throws IOException{
  DataOutputStream out = new DataOutputStream(
    new BufferedOutputStream(
      new FIleOutputStream("Data.txt")));
  out.writeDouble(3.14159);
  out.writeUTF("that wa pi");
  out.writeDouble(1.41413);
  out.writeUTF("Square root of 2");
  out.close();

  DataInputStream in = new DataInputStream(
    new BufferedInputStream(
      new FileInputStream("Data.txt"))):
  print(in.readDouble());
  //注意读入方式
  print(in.readUTF());
  print(in.readDouble());
  print(in.readUTF());
}

6. 读写随机访问文件
   RandomAccessFile组合了DataInput和DataOutput接口，并可以用seek()在文件中到处移动，并修改文件中的值。不支持装饰。

static String file = "rtest.dat";
static void display() throws IOException{
  RandomAccessFile rf = new RandomAccessFile(file, "r");
  for(int i=0; i<7; i++)
    println("Value " + i + ": " + rf.readDouble());
  println(rf.readUTF());
  rf.close();
}

public stativ void main(String[] args) throws IOException{
  RandomAccessFile rf = new RandomAccessFile(file, "rw");
  for(int i=0; i<7; i++)
    rf.writeDouble(i*1.414);
  rf.writeUTF("the end of the file");
  rf.close();
  dispaly();

  rf = new RandomAccessFile(file, "rw");
  rf.seek(5*8);//double8字节长
  rf.writeDouble(47.001);
  rf.close();
  dispaly();
}
}

7. 管道流
   PipedInputSream等管道流用于任务之间的通信，在多线程用处很大。

标准I/O

标准I/O参照Unix中“程序所使用的单一信息流”这一概念，程序的所有输入都可以来自标准输入，所有输出也可以发送到标准输出，所有错位信息都可以发送到标准错误。意义在于，方便将程序串联起来，像管道一样。
java提供System.in, System.out, System.err。

1. 从标准输入中读取
   为了使用readLine()，BufferedReader要求使用InputStreamReader把System.in转换成Reader。

public stativ void main(String[] args) throws IOException{
  BufferedReader stdin = new BufferedReader(
    new InputSreamReader(System.in));
  String s;
  while( (s = stdin.readLine()) != null && s.length!=0)
    System.out.println(s);
  //空行或者Ctrl-z终止程序
}

2. 将System.out转换成PrintWriter
   System.out是个PrintStream，PrintStream是一个OutputStream。PrintWriter有一个接受OutputSream作为参数的构造器。

PrintWriter out = new PrintWriter(System.out, true);

3. 标准I/O重定向
   System类提供静态方法，以将标准输入输出重定向：
   · setIn(InputStream)
   · setOut(PrintStream)
   · setErr(PrintStream)

进程控制

若要在java内部执行其他操作系统的程序，并且要控制这些程序的输入和输出，则需要进程控制。
比如运行程序，将输出发送到控制台。可以使用java.lang.ProcessBuilder。在使用时，可能会产生两种类型的错误，普通的导致异常的错误——抛出运行时异常，还有从进程自身的执行过程中产生的错误，可以用单独的异常报告来记录。

public static void command(String command){ //命令字符串
try{
  boolean err = false;
  Process process = new ProcessBuilder(command.split(" ")).start();
  BufferReader results = new BufferReader(
    new InputStreamReader(process.getInputStream()));
  String s;
  while((s = results.readLine()) != null)
    println(s);
  BufferedReader errors = new BufferedReader(
    new InputStreamReader(process.getErrorStream()));
  while((s = errors.readLine()) != null){
    println(s);
    err = true;
  }
 } catch(Exception e){
    throw new RuntimeException(e);
 }

NIO

实际上，java旧的I/O包已经使用nio重新实现过，以提高速度。速度的提高来自于所使用的结构更接近与操作系统执行I/O的方式：通道和缓冲器。直接与缓冲器交互，将缓冲器派送到通道。
唯一直接与通道交互的缓冲器是ByteBuffer——存储未加工字节（8字节）。将字节存放于ByteBuffer的方法：一是“put”直接填充一个或多个字节或基本数据类型的值。二是warp()将已存在的字节数组包装进ByteBuffer中。
FileInputStream、FileOutputStream、RandomAccessFile可以使用getChannel()产生FileChannel（ 一个读，写，映射，操作文件的通道）。

public class GetChannal {
  private static final int BSIZE = 1024;
  
  public stativ void main(String[] args) throws IOException{
    //写文件
    FileChannel fc =new FileOutputStream("data.txt").getChannel();
    fc.write(ByteBuffer.wrap("some text".getBytes()));
    fc.close();
    //将内容添加到文件尾部
    fc = new RandomAccessFile("data.txt").getChannel();
    fc.position(fc.size());
    fc.write(ByteBuffer.wrap("Some more".getBytes()));
    fc.close();
    //读文件
    fc = new FileInputStream("data.txt").getChannel();
    ByteBuffer buff = ByteBuffer.allocate(BSIZE);//allocateDirect()更快，资源消耗更多
    fc.read(buff);// FileChannel 向ByteBuffer存储字节
    buff.flip();//must 准备
    while(buff.hasRemaining())
      print((char)bugg.get());
  }
}

读写例子：

.....
FileChannel in = new FileInputStream("in.txt").getChannel(),
  out = new FileInputStream("out.txt").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(BSIZE);
while(in.read(buffer) != -1){
    buffer.flip(); //准备写
    out.write(buffer); //操作之后，信息仍在缓冲器
    buffer.clear(); //清理准备
}
....

使用transferTo()和transferFrom()能将两个通道相连。

...
in.transferTo(0, in.size(), out);
//或
out.transferFrom(in, 0, in.size());

转换数据：缓冲器放的是字节，要转换成字符，一是可以在输入的时候对其进行编码，二是从缓冲器输出是对其进行解码。可以使用java.nio.charset.Charset实现。

//第一种方法
String encoding = System.getProperty("file.encoding");
System.out.println("Decoded using " + encoding + ": "
      + Charset.forName(encoding).decode(buff));
//第二种
fc = new FileOutputStream("data2.txt").getChannel();
fc.write(ByteBuffer.wrap(
      "Some text".getBytes("UTF-16BE")));
fc.close();
// Now try reading again:
fc = new FileInputStream("data2.txt").getChannel();
buff.clear();
fc.read(buff);
buff.flip();
System.out.println(buff.asCharBuffer());
// 使用CharBuffer 写
fc = new FileOutputStream("data2.txt").getChannel();
buff = ByteBuffer.allocate(24); // More than needed
buff.asCharBuffer().put("Some text");
fc.write(buff);
fc.close();
// 再来读
fc = new FileInputStream("data2.txt").getChannel();
buff.clear();
fc.read(buff);
buff.flip();
System.out.println(buff.asCharBuffer());

获取基本类型：

ByteBuffer bb = ByteBuffer.allocate(BSIZE);
// Allocation automatically zeroes the ByteBuffer:
int i = 0;
while(i++ < bb.limit())
if(bb.get() != 0)
    print("nonzero");
print("i = " + i);
bb.rewind();
// Store and read a char array:
bb.asCharBuffer().put("Howdy!");
char c;
while((c = bb.getChar()) != 0)
   printnb(c + " ");
print();
bb.rewind();
// Store and read a short:
bb.asShortBuffer().put((short)471142);//需要类型转换
print(bb.getShort());
bb.rewind();
// Store and read an int:
bb.asIntBuffer().put(99471142);
//bb.asIntBuffer().put(new int[]{1,2,4,5,});
//bb.asIntBuffer().put(1,3,5);
print(bb.getInt());
bb.rewind();
// Store and read a long:
bb.asLongBuffer().put(99471142);
print(bb.getLong());
bb.rewind();
// Store and read a float:
bb.asFloatBuffer().put(99471142);
print(bb.getFloat());
bb.rewind();
// Store and read a double:
bb.asDoubleBuffer().put(99471142);
print(bb.getDouble());
bb.rewind();

除了short都不用类型转换。asXXBuffer()获取的是视图缓冲器XXBuffer。等底层的ByteBuffer通过视图缓冲器填满了基本类型是，就 直接写到通道中了。
缓冲器有四个索引操作：mark、positon、limit和capacity。

内存映射文件：允许创建和修改因太大而不能放入内存的文件，假定整个文件都在内存中，当做非常大的数组来访问。BufferXXX对大文件力不从心，而MapedByteBuffer就很适合。

static int length = 0x8FFFFFF; // 128 MB
public static void main(String[] args) throws Exception {
    MappedByteBuffer out = //ByteBuffer的子类
      new RandomAccessFile("test.dat", "rw").getChannel()
      .map(FileChannel.MapMode.READ_WRITE, 0, length);//初始位置和映射区域长度
    for(int i = 0; i < length; i++)
      out.put((byte)'x');
    print("Finished writing");
    for(int i = length/2; i < length/2 + 6; i++)
      printnb((char)out.get(i));
  }

文件加锁：
使用FileChannel调用tryLock()（非阻塞，若不能获取，则返回方法调用）或lock()（阻塞直至锁获得）就能获取整个文件的FileLock。如果返回值不为空，则可以进行操作。

压缩

压缩使用直接将输出流封装成GZIPOutputStream或ZipOutputStream，输入流封装成GZIPInputStream。。即可。批量的话有ZipEntry对每个entry操作。

对象序列化

java的对象序列化将实现了Serializable接口的对象转换成字节序列，并能通过字节序列恢复对象，可以利用这个实现轻量级持久性。这主要为了支持java的RMI和java Beans。
要序列化一个对象，首先OutputStream对象，然后将其封装再ObjectOutputStream对象内，调用writeObject()对象序列化，并将其发送到OutputStream。对象序列化是基于字节的。
若有特殊需要，可以实现Externalizable接口（继承了Serializable接口，添加了两个方法，writeExternal()和readExternal()）。Externalizable对象默认不保存任何字段。
一般序列化默认无参构造器。若有参数，则需要实现Externalizable接口

public class Blip3 implements Externalizable {
  private int i;
  private String s; // No initialization
  public Blip3() {
    print("Blip3 Constructor");
    // s, i not initialized
  }
  public Blip3(String x, int a) {
    print("Blip3(String x, int a)");
    s = x;
    i = a;
    // s & i initialized only in non-default constructor.
  }
  public String toString() { return s + i; }
  public void writeExternal(ObjectOutput out)
  throws IOException {
    print("Blip3.writeExternal");
    // You must do this:
    out.writeObject(s);
    out.writeInt(i);
  }
  public void readExternal(ObjectInput in)
  throws IOException, ClassNotFoundException {
    print("Blip3.readExternal");
    // You must do this:
    s = (String)in.readObject();
    i = in.readInt();
  }
  public static void main(String[] args)
  throws IOException, ClassNotFoundException {
    print("Constructing objects:");
    Blip3 b3 = new Blip3("A String ", 47);
    print(b3);
    ObjectOutputStream o = new ObjectOutputStream(
      new FileOutputStream("Blip3.out"));
    print("Saving object:");
    o.writeObject(b3);
    o.close();
    // Now get it back:
    ObjectInputStream in = new ObjectInputStream(
      new FileInputStream("Blip3.out"));
    print("Recovering b3:");
    b3 = (Blip3)in.readObject();
    print(b3);
  }
} 

transient关键字：若不希望对某个子对象序列化。

Externalizable替代方法

可以实现Serializable接口，并添加名为writeObject()和readObject()的私有方法。

private void writeObject(ObjectOutputStream stream) throws IOException;
private void readObject(ObjectOutputStream stream) throws IOException, ClassNotFoundException;

在方法内部，可以调用defaultWriteObjec()或者defaultReadObject()。非transient字段一定要在之前调用defaultXXX(), transient字段一定要明确保存和恢复。

public class SerialCtl implements Serializable {
  private String a;
  private transient String b;
  public SerialCtl(String aa, String bb) {
    a = "Not Transient: " + aa;
    b = "Transient: " + bb;
  }
  public String toString() { return a + "\n" + b; }
  private void writeObject(ObjectOutputStream stream)
  throws IOException {
    stream.defaultWriteObject();
    stream.writeObject(b);
  }
  private void readObject(ObjectInputStream stream)
  throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    b = (String)stream.readObject();
  }
  public static void main(String[] args)
  throws IOException, ClassNotFoundException {
    SerialCtl sc = new SerialCtl("Test1", "Test2");
    System.out.println("Before:\n" + sc);
    ByteArrayOutputStream buf= new ByteArrayOutputStream();
    ObjectOutputStream o = new ObjectOutputStream(buf);
    o.writeObject(sc);
    // Now get it back:
    ObjectInputStream in = new ObjectInputStream(
      new ByteArrayInputStream(buf.toByteArray()));
    SerialCtl sc2 = (SerialCtl)in.readObject();
    System.out.println("After:\n" + sc2);
  }
} /* Output:
Before:
Not Transient: Test1
Transient: Test2
After:
Not Transient: Test1
Transient: Test2
*///:~

XML

XOM类库可以实现对象xml化。还有个Serializer类将XML转换为可读性的格式。

Preferences

Preference API用于存储和读取用户的偏好以及程序配置项的设置，是一个键-值集合，简单好上手。
补充资料