java核心技术之流与文件

　　InputStream和OutputStream构成了输入/输出类层次结构的基础。用于按字节进行读写。而与之处在同一等级的Reader/Writer同样作为抽象类定义了用于对字符进行读取的类层次结构，是基于两个字节的Unicode码元的读取。

　　inputStream的抽象方法abstract int read(),每次读入一个字节并返回一个int值，在遇到文件尾的时候返回-1.所以可以用其子类FileInputStream进行文件字符读取：

FileInputStream f = new FileInputStream("C:\\Users\\Loki\\Desktop\\io.txt");
        int i;
        while((i=f.read()) != -1){
            System.out.print((char)i);
        }

　　同样OutputStream的抽象方法abstract void write()每次写入一个字节，比如用其子类FileOutputStream进行写入：

FileOutputStream out = new FileOutputStream("C:\\Users\\Loki\\Desktop\\output.txt");
        char[] chars = {'a','b','c','d','e'};　　　　//java中char是两个字节表示。
        for(int j = 0; j < chars.length; j++){     //如果用write写入int类型变量，则低8位被写入，高24位被忽略。
            out.write(chars[j]);
        }

　　read和write方法在执行时都将阻塞，直至字节被读入或写出。此外可以通过available()方法得知可读入字节数，也可以以数组的形式进行读取。

　　同样的，InputStreamReader类也是从文件中读取字节，并以int的形式返回，遇到文件尾则返回-1。但是它与上面的InputStream有什么不同呢？不同点就在于InputStream没有指定解析字节的编码方式，只是纯粹地读取一个字节的内容并原原本本地返回。而InputStreamReader类的构造器是以输入流为参数并且可以指定编码方式，比如可以以InputStream实例对象为参数并指定“GBK”编码方式，以“GBK”编码方式解析从InputStream输入流返回的字节，解析完了之后再返回对应字符的Unicode对应的代码值（代码点）。java核心技术上说 “InputStreamReader 类将包含字节（用某种字符编码方式表示的字符）的输入流转换为转换为可以产生Unicode码元的读入器”。以下是实例代码和输出，文件中的文字是“小岳岳是河南人”，第一行是InputStream的输出，第二行是InputStreamReader的输出：

FileInputStream f2 = new FileInputStream("C:\\Users\\Loki\\Desktop\\io.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(f2,"gbk");
        while((i = inputStreamReader.read()) != -1)
            System.out.print((char)i);
 
Ð¡ÔÀÔÀÊÇºÓÄÏÈË
小岳岳是河南人
Process finished with exit code 0

根据以上描述，相应的OutpStreamReader类在输出的时候要指定一个输出流，并且可选地选定编码方式。

　　当然，如果要是像文件写入文本的话，最方便的还是PrintWriter类，对于这个类的使用是跟System.out是一样的，它把数字、字符、boolean值以“utf-8"的编码格式编码成的字符串的形式输出到指定位置。关于编码格式，可以通过上面的InPuStreamReader验证。以下例程：

 PrintWriter printWriter = new PrintWriter("C:\\Users\\Loki\\Desktop\\output.txt");
        printWriter.println();
        printWriter.println("今天天气不错");
        printWriter.println(24);
        printWriter.println(true);
        printWriter.println('c');
        printWriter.flush();
 
文档内容：
 
今天天气不错
24
true
c

　　对应文本的读入之前是用BufferedReader，不过建议用Scanner。在下面的例程中，刚开始没有用System.out把in.nextLine()输出，导致程序一直没有输出。所以以后看Api的时候一定要好好看函数的返回类型：

Scanner in = new Scanner(System.in);
        while(in.hasNextLine())  //对应于单个字符有.hasNext()和.next()方法。具体查看Api
        {
            System.out.println(in.nextLine());
        }

字符集中的编码方式可以在java中的unicode字符和编码而成的字节之间进行转换。获取字符集对象的方式为Charset.forName("utf-8");这与反射中通过名字构造类实例一样（Class cl = Class.forName("java.util.Scanner");）。

　　下面是如何编码java字符串：

　　　　String str = ...;

　　　　ByteBuffer buffer = Charset.forName("...");

　　　　byte[] bytes = buffer.array();

　　解码字节序列：

　　　　byte[] bytes = ...;

　　　　ByteBuffer bbuf = ByteBuffer.wrap(bytes,offset,length);　　

　　　　CharBuffer cbuf = cset.decode(bbuf);

　　　　String str = cbuf.toString();

　　DataOutput接口定义了一些方法，这些方法以二进制的格式写数组、字符、boolean值。比如writeInt总是把一个整数写出为4字节的二进制整数量。而DataInput在输入的时候需要用一个输入流初始化。

　　随机访问文件类RandomAccessFile类的思想与C语言中的文件读取思想是一致的，可以选择只读(r)或可读可写(rw)，还可以获得获得文件指针，也能够设置文件指针的位置。它同时实现了DataOutput和DateInput的方法，所以可以用这两个接口中的方法对文件进行读取。

　　读取Zip文档的时候要用到ZipInputStream类，以下是两种读取方法，但是注意，Scanner方法要比直接用read方法的效果要好：

ZipInputStream zin = new ZipInputStream(new FileInputStream("C:\\Users\\Loki\\Desktop\\Desktop.zip"));
        ZipEntry entry;
        while((entry = zin.getNextEntry()) != null){
            Scanner scanner = new Scanner(zin);
            while (scanner.hasNextLine())
                System.out.println(scanner.nextLine());
            zin.closeEntry();
        }
 
        /*
        while((entry = zin.getNextEntry()) != null){
            int i;
            while((i = zin.read()) != -1)
                System.out.print((char)i);
            zin.closeEntry();
        }
        */
        zin.close();

序列化：

　　序列化是一种传递对象的方式，以序列号代替内存地址标记不同的对象。为什么要用序列号而不是内存地址呢，因为虚拟机会对内存机进行整理从而改变对象的内存地址，所以用内存地址标记一个对象是不可靠的。

　　先对序列化有一个直观的认识。序列化是将对象写出到流中、之后再将其读回。为了写出和读回，我们需要用到ObjectInputStream和ObjectOutputStream类，顾名思义，对象输入和输出流。如下程序所示:

public static void main(String[] args) throws IOException,ClassNotFoundException{
 
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Loki\\Desktop\\io.txt"));
        Student li = new Student("LiSi", 24,2);
        Student zhang = new Student("ZhangSan", 24,3);
        out.writeObject(li);
        out.writeObject(zhang);
        out.close();
 
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("C:\\Users\\Loki\\Desktop\\io.txt"));
        Student copyLi = (Student)in.readObject(); //要抛出ClassNoteFountException
        Student copyZhang = (Student)in.readObject();
 
        System.out.println(copyLi.getName());          //注意这里面的copyLi和li是数据域相同的不同的对象。
        System.out.println(copyZhang.getName());
 
    }
}
 
class Student implements Serializable{
    private String name;
    private int age;
    private int grade;
 
    public Student(){
 
    }
    public Student(String aName, int aAge, int aGrade){
        name = aName;
        age = aAge;
        grade = aGrade;
    }
    ...
    ...
    ...
}

需要注意的有两点，其一：要抛出ClassNotFountException异常；其二：要实现Serializable接口，这是一个标记接口，没有任何方法。

也可以序列化基本类型，用到的方法是writeInt这些方法，因为ObjectInputStream和ObjectOutputStream类实现了DataInput和DataOutput接口。

因为每个对象都是用序列号保存的，所以这种机制被称为序列化，以下是其算法：

　　1. 遇到的每一个对象都关联一个序列号；

　　2. 对于每一个对象，第一次遇到时将其对象保存到流中（保存的是域以及类信息）；

　　3. 如果遇到的对象已经被保存过，那么只写"与之前保存过的序列号为x的对象相同”；

　　4. 读取对象的时候过程相反。

　　如果类中有不可序列化的域，则应该标记为transient，在序列化时会被跳过。为了存储这些不可序列化的域，可序列化的类可以定义具有以下签名的私有方法：

private void readObject(ObjectInputStream in) throws IOException,ClassNotFoundException;
private void writeObject(ObjectOutputStream out) throws IOException;

之后数据域就不会再被自动序列化，而是被用反射机制调用来序列化对象，在这种私有方法的内部实现类似于下面所示：

private void writeObject(ObjectOutputStream out){
    out.defaultWriteObject();
    out.writeDouble(x);
    out.writeDouble(y);
}

　　其中通过defaultWriteObject方法序列化可被序列化的域，然后用标砖的DataOutput调用写出不可被序列化的域。

外部化(Externalizable):

　　除了使用序列化机制来保存和恢复对象数据之外，类还可以定义自己的机制，那就是外部化。外部话可以弥补序列化不能记录超类中数据的缺点。使用外部化时类要实现Exteinalizable接口，并实现readExternal和writeExternal方法，这两个方法是公共方法。

void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

在方法的具体实现中，可以通过调用DataOutput和DataInput的标准方法来输入和输出数据。

读写文件：

　　Files类可以使得对普通的文件的读写变得快捷。这个类主要用于处理中等长度的文本文件，在读取的时候它可以全部按字节读取或者当作行序列读取，有如下方法:

byte[] bytes = Files.readAllBytes(path);
String content = new String(bytes, charset); //将上面读出的byte以特定的编码方式转换为字符串
//也可以把文件当作行序列读出
List<String> lines = Files.readAllLines(path, charset);
 
//写出到文件
Files.write(path, content.getBytes(charset));
//追加
Files.write(path, content.getBytes(charset), StandardOpenOption.APPEND);
//将一个行的集合写入到文件中
Files.write(path, lines);

　　对于长文本文件和二进制文件，还是需要用传统的读入器/写出器，Files类的静态方法提供一些方法来获取读入/写出器，避免了上述的繁琐方法：

InputStream in = Files.newInputStream(path);
OutputStream out = Files.newOutputStream(path);
 
Reader in = Files.newBufferedReader(path, charset);
Writer out = Files.newBufferedWriter(path, charset);

　　Files类提供了移动、删除、复制文件的一些方法。

参考：

　　http://blog.163.com/fan_yishan/blog/static/47692213200821595727205/

　　java核心技术卷二