文件读写方式简单综述

Java Socket通信实例：[url]http://donald-draper.iteye.com/blog/2356695[/url]
Java Socket读写缓存区Writer和Reader:[url]http://donald-draper.iteye.com/blog/2356885[/url]
Java序列化与反序列化实例分析：[url]http://donald-draper.iteye.com/blog/2357515[/url]
FileChannel示例：[url]http://donald-draper.iteye.com/blog/2373661[/url]
FileChanne定义：[url]http://donald-draper.iteye.com/blog/2374149[/url]
[size=medium][b]引言：[/b][/size]
在Java序列化与反序列化实例分析文章我们用ObjectInput/OutputStream将对象序列化到文件，FileChannel示例这篇文章中我们通过文件通道读写文件，ObjectInput/OutputStream读写文件是面向字节流的读写文件方式，fileChannel是面向通道的读写文件方法（ByteBuffer），还有一种是面向字符流的读取文件方式，及Reader和Writer，今天主要来看面向字节流和面向字符流的读取文件方法。
测试实例：

package nio.file;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
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.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.attribute.FileAttribute;
import java.util.Set;

/**
 * 测试读写文件
 * @author donald 
 * 2017年5月12日 
 * 下午11:33:14
 * @see java.io.FileInputStream#getChannel()//读模式
 * @see java.io.FileOutputStream#getChannel()//写模式
 * @see java.io.RandomAccessFile#getChannel()//以创建RandomAccessFile的模式为准，r，rw。
 */
public class testFile {
	private static File file = null;
	public static void main(String[] args) throws IOException {
         file = new File("E:/file/dir/test.txt");
         String pathStr = file.getPath();//路径中包括文件名和文件后缀
         System.out.println("文件路径："+pathStr);
         System.out.println("文件绝对路径："+file.getAbsolutePath());
         System.out.println("文件规范路径："+file.getCanonicalPath());//返回路径的规范格式，与系统有关
         System.out.println("文件父路径："+file.getParent());
         System.out.println("完整文件名："+file.getName());//默认返回的文件名是包括后缀的
         System.out.println("文件名："+file.getName().split("\\.")[0]);
         System.out.println("文件类型："+file.getName().split("\\.")[1]);
         System.out.println("文件分隔符："+file.separator);
         System.out.println("是否绝对路径："+file.isAbsolute());
         System.out.println("是否为目录："+file.isDirectory());
         System.out.println("是否为文件："+file.isFile());
         System.out.println("是否为隐藏文件："+file.isHidden());
         System.out.println("文件是否可读："+file.canRead());
         System.out.println("文件是否可写："+file.canWrite());
         System.out.println("文件是否可执行："+file.canExecute());
//         testMkdirs();

         if(file.exists()){
        	 file.delete();
         }
         if(!file.exists()){
        	 createFile(file);
         }
        testListRoots();
        testListFiles(file);
         /*
          * 这里的Path，就是我们在FileChannle定义文章中，要打开一个文件通道，要传入一个Path参数
          * FileChannel open(Path path,Set<? extends OpenOption> options,FileAttribute<?>... attrs)
          * */
         Path path = file.toPath();
         System.out.println("Path文件类型："+path.getClass());
         //FileOutputStream
         //第二个参数为true，表示从文件末尾开始写，只写模式
         FileOutputStream fileOutputStream = new FileOutputStream(file,true);
         String writeString = "test FileOutputStream write...";
         fileOutputStream.write(writeString.getBytes("UTF-8"));
         System.out.println("===写字节序列到文件输出流完成======");
//         fileOutputStream.getChannel();//获取写模式文件通道
         fileOutputStream.close();

         //FileInputStreams
         FileInputStream fileInputStream = new FileInputStream(file);
         int fisAvailable = fileInputStream.available();
         System.out.println("==文件输入流可用字节数："+fisAvailable);
         byte[] readBytes = new byte[fisAvailable];
         System.out.println("从文件输入流读取字节数："+fileInputStream.read(readBytes));
         System.out.println("从文件输入流内容："+new String(readBytes,"UTF-8"));
//         fileInputStream.getChannel();//获取读模式文件通道
         fileInputStream.close();

        /* FileOutput/InputStream,主要用于读写文件，面向字节流的*/

         //BufferedOutputStream
         BufferedOutputStream  bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(file,true));
         bufferedOutputStream.write(new String("test BufferedOutputStream write...").getBytes("UTF-8"));
         System.out.println("===写字节序列到缓冲区输出流======");
         bufferedOutputStream.flush();
         System.out.println("===刷新缓冲区字节序列到输出流完毕======");
         bufferedOutputStream.close();

         //BufferedInputStream
         BufferedInputStream  bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
         int bisAvailable = bufferedInputStream.available();
         System.out.println("==缓存区输入流可用字节数："+bisAvailable);
         byte[] readBytesfromBuffer = new byte[bisAvailable];
         System.out.println("从缓存区输入流读取字节数："+bufferedInputStream.read(readBytesfromBuffer));
         System.out.println("从缓存区输入流内容："+new String(readBytesfromBuffer,"UTF-8"));
         bufferedInputStream.close();

         /*
          * BufferedInputStream，BufferedOutputStream，也可以用于读写socket（Bio）输入/出流
          * 针对字节流，在写字节序列，先放入缓冲区中，调用flush方法，可以缓冲区字节序列更新到底层输出流
         */

         /*
          *  public DataOutputStream(OutputStream out) {
		  *     super(out);
		  *   }
          */
         //DataOutputStream构造中的OutputStream，可以为socket（Bio）输出流，或FileInputStream  
         DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(file,true));;
         dataOutputStream.close();
         /*
          *  public DataInputStream(InputStream in) {
		  *     super(in);
		  * }
          */
         //DataInputStream构造中的InputStream，可以为socket（Bio）输入流，或FileInputStream
         DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file));
         dataInputStream.close();
         /*
          * DataInputStream,DataOutputStream,除了处理字节序列之外，也可以原始类型Int，Char，Long，Double，
          * Float,Boolean等
          */


//       ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file,true));
//       objectOutputStream.writeObject(obj);
//       objectOutputStream.close();
//       ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
//       objectInputStream.readObject();
//       objectInputStream.close();  

         /*
          * ObjectOutput/InputStream构造中的Output/InputStream，可以为socket（Bio）输出流/输入流，
          * 或FileOutput/InputStream,ObjectOutput/InputStream除了可以处理字节序列之外，也可以原始类型Int，
          * Char，Long，Double，Float,Boolean等，主要用于对象的序列化和反序列化;
          * 这部分测试的话，最好先写一个对象到文件，然后在读取，因为写对象的时候，要将魔数等信息写进去
          */
           System.out.println("=======测试Writer，Reader=====");
           if(file.exists()){
          	 file.delete();
           }
           if(!file.exists()){
          	 createFile(file);
           }
           FileWriter fileWriter = new FileWriter(file, true);
           fileWriter.write("test FileWriter write...");
           fileWriter.flush();
           fileWriter.close();
           System.out.println("==fileWriter写字符串完毕");
           FileReader fileReader = new FileReader(file);
           char[] readChars = new char[24];
           if(fileReader.ready()){
        	   System.out.println("==fileReader读取字符数:"+fileReader.read(readChars));
        	   System.out.println("==fileReader读取结果:"+new String(readChars));
           }
           fileReader.close();

           /* FileWriter/Reader,主要用于读写文件，面向字符流的*/

         /*
          * public OutputStreamWriter(OutputStream out, String charsetName)
          */
         OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file,true),"UTF-8");
         BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
         bufferedWriter.newLine();
         bufferedWriter.write("test BufferedWriter write...");
         bufferedWriter.newLine();
         bufferedWriter.flush();
         bufferedWriter.close();
         System.out.println("==bufferedWriter写字符串完毕");
         /*
          *  public InputStreamReader(InputStream in, String charsetName)
          */
         InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file),"UTF-8");
         BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
         if(bufferedReader.ready()){
        	 System.out.println("==bufferedReader读取一行字符串："+bufferedReader.readLine());
             System.out.println("==bufferedReader读取一行字符串："+bufferedReader.readLine());
         }
         bufferedReader.close();
         /*
          * BufferedWriter/Reader,读写文件，可以将文件先包装成FileOutput/InputStream,
          * 再根据FileOutput/InputStream，构造OutputStreamWriter/InputStreamReader,
          * 最后OutputStreamWriter/InputStreamReader构造BufferedWriter/Reader,就可以
          * 通过BufferedWriter/Reader读写文件；从上面可以看出OutputStreamWriter/InputStreamReader
          * 的构造关键参数为Output/InputStream,我们从Socket（BIO），获取socket输入流和输出流，
          * 包装成OutputStreamWriter/InputStreamReader，那么我们就可以通过BufferedWriter/Reader
          * 读socket输入流和写socket输出流。
          */
         RandomAccessFile randomAccessFile = new RandomAccessFile(file,"rw");
         //这里就不具体介绍了，F3，看看具体非方法声明，就知道怎么回事了
//       randomAccessFile.getChannel();//获取读写模式文件通道
         randomAccessFile.close();
         /**
          * 前面无论是面向字节的，还是面向字符的流，都是读写分离的，而RandomAccessFile,是
          * 可读可写的；可写字节序列，原始类型，可读字节序列，原始类型，按行读取；
          * 
          */ 

//         FileChannel fileChannel = randomAccessFile.getChannel();
         /**
          * 这种方式为通过通道读写文件，在前面的文章以说，这里不再说
          */
	   File tfile = File.createTempFile("testFile", ".tmp", new File("E:/file/dir/"));
           if(tfile.exists()){
          	 System.out.println("==创建临时文件成功："+tfile.getName());
           }
           tfile.deleteOnExit();//针对临时文件
	}
	/**
	 * 测试创建文件目录方法
	 */
	public static void testMkdirs(){
		 if(!file.exists()){
        	 System.out.println("========文件不存在========");
        	 System.out.println("========创建文件路径："+file.mkdir());
         }
		 if(!file.exists()){
        	 System.out.println("========文件不存在========");
        	//当父路径不存在时，循环创建父类路径,包括文件名和后缀
        	 System.out.println("========循环创建父类路径："+file.mkdirs());
         }
	}
	/**
	 * 创建文件
	 * @param f
	 * @return
	 * @throws IOException 
	 */
	public static File createFile(File f) throws IOException{
		 if(!f.exists()){
        	 //创建文件时，如果文件父路径不存在，则应先创建创建路径，然后再创建文件
        	 f.getParentFile().mkdirs();
        	 if(f.getParentFile().exists()){
        		 System.out.println("========创建文件："+f.createNewFile());
        		 System.out.println("创建文件过后，是否为文件："+file.isFile());
        		 System.out.println("========是否为隐藏文件："+file.isHidden());
        		 System.out.println("========文件是否可读："+file.canRead());
        		 System.out.println("========文件是否可写："+file.canWrite());
                 System.out.println("========文件是否可执行："+file.canExecute());
        	 }
         }
		 return f;
	}
	/**
	 * 获取文件系统的更目录，unix下，根目录为/
	 * windows为C:，D:,E:...
	 */
	public static void testListRoots(){
		 System.out.println("文件系统根目录size："+File.listRoots().length);
         for(File tfile : File.listRoots()){
        	 System.out.print(tfile.getPath()+",");
         }
         System.out.println();
	}
	/**
	 * 获取文件当前目录下的文件
	 * @param lf
	 */
	public static void testListFiles(File lf){
		File parentFile = lf.getParentFile();
	    System.out.println("当前文件目录下的文件size："+parentFile.listFiles().length);
	    for(File tfile : parentFile.listFiles()){
	   	 System.out.print(tfile.getPath()+",");
	    }
	    System.out.println();
	}
}

执行程序，控制台输出：
文件路径：E:\file\dir\test.txt
文件绝对路径：E:\file\dir\test.txt
文件规范路径：E:\file\dir\test.txt
文件父路径：E:\file\dir
完整文件名：test.txt
文件名：test
文件类型：txt
文件分隔符：\
是否绝对路径：true
是否为目录：false
是否为文件：true
是否为隐藏文件：false
文件是否可读：true
文件是否可写：true
文件是否可执行：true
========创建文件：true
创建文件过后，是否为文件：true
========是否为隐藏文件：false
========文件是否可读：true
========文件是否可写：true
========文件是否可执行：true
文件系统根目录size：5
C:\,D:\,E:\,F:\,G:\,
当前文件目录下的文件size：1
E:\file\dir\test.txt,
Path文件类型：class sun.nio.fs.WindowsPath
===写字节序列到文件输出流完成======
==文件输入流可用字节数：30
从文件输入流读取字节数：30
从文件输入流内容：test FileOutputStream write...
===写字节序列到缓冲区输出流======
===刷新缓冲区字节序列到输出流完毕======
==缓存区输入流可用字节数：64
从缓存区输入流读取字节数：64
从缓存区输入流内容：test FileOutputStream write...test BufferedOutputStream write...
=======测试Writer，Reader=====
========创建文件：true
创建文件过后，是否为文件：true
========是否为隐藏文件：false
========文件是否可读：true
========文件是否可写：true
========文件是否可执行：true
==fileWriter写字符串完毕
==fileReader读取字符数:24
==fileReader读取结果:test FileWriter write...
==bufferedWriter写字符串完毕
==bufferedReader读取一行字符串：test FileWriter write...
==bufferedReader读取一行字符串：test BufferedWriter write...
==创建临时文件成功：testFile5597549589275073288.tmp

[size=medium][b]总结：[/b][/size]
[color=blue] File表示的系统文件，可以是目录，可以是实际文件。创建文件时首先要确保实际文件的父目录要存在。通过文件获取的文件名，返回的是完整文件名，即文件名+后缀（文件类型）。
FileOutput/InputStream,主要用于面向字节流读写文件方式；读文件文件我们还可以借助其他字节流比如：
BufferedOutput/InputStream在写字节序列，先放入缓冲区中，调用flush方法，
可以缓冲区字节序列更新到底层输出流；
DataOutput/InputStream,除了处理字节序列之外，也可以处理原始类型Int，Char，
Long，Double，Float,Boolean等；
ObjectOutput/InputStream除了可以处理字节序列之外，也可以原始类型，主要用于对象的序列化和反序列化;
上述三种字节流的构造中，都有一个构造参数，即Output/InputStream，可以为socket（BIO）输出流/输入流，或FileOutput/InputStream。
FileWriter/Reader,为面向字符流的读写文件方式；也可以通过BufferedWriter/Reader,读写文件，可以将文件先包装成FileOutput/InputStream,再根据FileOutput/InputStream，构造OutputStreamWriter/InputStreamReader,最后OutputStreamWriter/InputStreamReader构造BufferedWriter/Reader,就可以通过BufferedWriter/Reader读写文件；而OutputStreamWriter/InputStreamReader的构造关键参数为Output/InputStream,
我们可以从Socket（BIO），获取socket输入流和输出流，包装成OutputStreamWriter/InputStreamReader，那么我们就可以通过BufferedWriter/Reader读socket输入流和写socket输出流。OutputStreamWriter/InputStreamReader，是字节流与字符流的桥接，写操作，字符流使用Charset编码成字节流，以字节流的形式发送底层字节流。Charset编码可设置，如果没有设定，则用默认的编码，读操作类似。
上述中的面向字节流和字符流中带Buffered*，是可以缓存字节序列和字符串，写操作过后，要调用flush，更缓存数据到底层的输出流。
当然读写文件的方式也可以通过RandomAccessFile，和FileChannel。读取文件，建议
用FileChannel方法，因为FileChannel直接将文件映射到物理内存中，读写更高效，如果对
性能没有要求，可以用面向字节流（Output/InputStream）和字符流（Writer/Reader）的方式。
无论面向字节的，还是面向字符的流，都是读写分离的，而RandomAccessFile,是可读可写的；可写字节序列，原始类型，可读字节序列，原始类型，按行读取。字节流，字符流，RandomAccessFile为java io（JDK1.0,1.1）包中的工具类，文件通道FileChannel为java nio（JDK1.4）包中的工具类。[/color]
文件读写方式简单综述后续（文件，流构造）:[url]http://donald-draper.iteye.com/blog/2374294[/url]
附：
//FileOutputStream

public class FileOutputStream extends OutputStream

[img]http://dl2.iteye.com/upload/attachment/0124/8253/a47e4642-57f3-31fa-a03e-e37ba0b2a923.png[/img]


//FileInputStream

public class FileInputStream extends InputStream

[img]http://dl2.iteye.com/upload/attachment/0124/8255/0450523d-c117-30f8-92e7-c136b0dcca14.png[/img]

//BufferedOutputStream

public class BufferedOutputStream extends FilterOutputStream 

[img]http://dl2.iteye.com/upload/attachment/0124/8257/7f346809-7f63-3030-86bc-55ff7443bced.png[/img]

//FilterOutputStream

public class FilterOutputStream extends OutputStream 

[img]http://dl2.iteye.com/upload/attachment/0124/8259/c4958391-f9e5-31fc-9a46-670d3ab7fd05.png[/img]


//BufferedInputStream

public class BufferedInputStream extends FilterInputStream 

[img]http://dl2.iteye.com/upload/attachment/0124/8261/bd7ae2e0-3cff-3f1f-8d95-44ca7183340e.png[/img]

//FilterInputStream

public class FilterInputStream extends InputStream 

[img]http://dl2.iteye.com/upload/attachment/0124/8263/6abe904c-e538-319b-86de-e6e07a3991a4.png[/img]

 /* @author  Arthur van Hoff
 * @see     java.io.BufferedOutputStream
 * @see     java.io.ByteArrayOutputStream
 * @see     java.io.DataOutputStream
 * @see     java.io.FilterOutputStream
 * @see     java.io.InputStream
 * @see     java.io.OutputStream#write(int)
 * @since   JDK1.0
 */
//OutputStream
public abstract class OutputStream implements Closeable, Flushable

[img]http://dl2.iteye.com/upload/attachment/0124/8265/1634418a-63f7-3411-bd56-51f63f4cd658.png[/img]

 /* @author  Arthur van Hoff
 * @see     java.io.BufferedInputStream
 * @see     java.io.ByteArrayInputStream
 * @see     java.io.DataInputStream
 * @see     java.io.FilterInputStream
 * @see     java.io.InputStream#read()
 * @see     java.io.OutputStream
 * @see     java.io.PushbackInputStream
 * @since   JDK1.0
 */
//InputStream
public abstract class InputStream implements Closeable

[img]http://dl2.iteye.com/upload/attachment/0124/8267/0ecaa8d5-577a-332c-9a9f-6915fb727b6b.png[/img]


//DataOutputStream

public class DataOutputStream extends FilterOutputStream implements DataOutput 

[img]http://dl2.iteye.com/upload/attachment/0124/8269/9cc5ab5a-3d1c-3842-b1a5-d0f25233aad8.png[/img]

/* @author  Frank Yellin
 * @see     java.io.DataInput
 * @see     java.io.DataOutputStream
 * @since   JDK1.0
 */
//DataOutput 
public interface DataOutput {

[img]http://dl2.iteye.com/upload/attachment/0124/8271/e7c8b259-8d46-320c-b867-2ca973a4ec89.png[/img]


//DataInputStream

public class DataInputStream extends FilterInputStream implements DataInput

[img]http://dl2.iteye.com/upload/attachment/0124/8273/270a38c8-ef58-3288-8d9a-dd80e3a5ce1e.png[/img]

/* @author  Frank Yellin
 * @see     java.io.DataInputStream
 * @see     java.io.DataOutput
 * @since   JDK1.0
 */
public interface DataInput {
//DataInput

[img]http://dl2.iteye.com/upload/attachment/0124/8275/85600a44-293a-3d0f-aa55-b40b536b1128.png[/img]

 /* @author      Mike Warres
 * @author      Roger Riggs
 * @see java.io.DataOutput
 * @see java.io.ObjectInputStream
 * @see java.io.Serializable
 * @see java.io.Externalizable
 * @see [url=../../../platform/serialization/spec/output.html]Object Serialization Specification, Section 2, Object Output Classes[/url]
 * @since       JDK1.1
 */
 //ObjectOutputStream
public class ObjectOutputStream
    extends OutputStream implements ObjectOutput, ObjectStreamConstants

[img]http://dl2.iteye.com/upload/attachment/0124/8277/3e11a3d9-acae-3aff-8873-d65faa1db868.png[/img]

/* @author  unascribed
 * @see java.io.InputStream
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @since   JDK1.1
 */
 //ObjectOutput
public interface ObjectOutput extends DataOutput, AutoCloseable

[img]http://dl2.iteye.com/upload/attachment/0124/8279/99f4de9d-f0e0-3073-9e1b-62e256be4623.png[/img]

/* @author      Mike Warres
 * @author      Roger Riggs
 * @see java.io.DataInput
 * @see java.io.ObjectOutputStream
 * @see java.io.Serializable
 * @see [url=../../../platform/serialization/spec/input.html] Object Serialization Specification, Section 3, Object Input Classes[/url]
 * @since   JDK1.1
 */
//ObjectInputStream
public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants

[img]http://dl2.iteye.com/upload/attachment/0124/8281/e171e2fe-c513-3fc9-995c-ad60b45503c8.png[/img]

/* @author  unascribed
 * @see java.io.InputStream
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @since   JDK1.1
 */
 //ObjectInput
public interface ObjectInput extends DataInput, AutoCloseable

[img]http://dl2.iteye.com/upload/attachment/0124/8283/24018d11-cc0a-3869-b213-efd2becc4b91.png[/img]


//FileWriter

/* @see OutputStreamWriter
 * @see FileOutputStream
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class FileWriter extends OutputStreamWriter {

[img]http://dl2.iteye.com/upload/attachment/0124/8285/9d20164b-cab1-3b41-8b17-546bf885bef0.png[/img]


//OutputStreamWriter

/* @see BufferedWriter
 * @see OutputStream
 * @see java.nio.charset.Charset
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class OutputStreamWriter extends Writer {

[img]http://dl2.iteye.com/upload/attachment/0124/8287/908f9cbd-df13-33c8-98bb-607074dd2354.png[/img]


//FileReader

 /* @see InputStreamReader
 * @see FileInputStream
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class FileReader extends InputStreamReader {

[img]http://dl2.iteye.com/upload/attachment/0124/8289/0f1bf2b5-ce89-37f7-8420-d14884fe7fa2.png[/img]


//InputStreamReader

/* @see BufferedReader
 * @see InputStream
 * @see java.nio.charset.Charset
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class InputStreamReader extends Reader {

[img]http://dl2.iteye.com/upload/attachment/0124/8291/73a4a22c-49b3-3b77-88ad-12965bf6226a.png[/img]

//BufferedWriter

/* @see PrintWriter
 * @see FileWriter
 * @see OutputStreamWriter
 * @see java.nio.file.Files#newBufferedWriter
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class BufferedWriter extends Writer {

[img]http://dl2.iteye.com/upload/attachment/0124/8293/07b8baaa-3c87-3672-aff5-7c005bdf2a97.png[/img]


//BufferedReader

/* @see FileReader
 * @see InputStreamReader
 * @see java.nio.file.Files#newBufferedReader
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public class BufferedReader extends Reader {

[img]http://dl2.iteye.com/upload/attachment/0124/8295/740faa73-b194-3fef-bf21-977a21429a30.png[/img]

//Writer
/* @see Writer
 * @see   BufferedWriter
 * @see   CharArrayWriter
 * @see   FilterWriter
 * @see   OutputStreamWriter
 * @see     FileWriter
 * @see   PipedWriter
 * @see   PrintWriter
 * @see   StringWriter
 * @see Reader
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */

//Writer
public abstract class Writer implements Appendable, Closeable, Flushable {

[img]http://dl2.iteye.com/upload/attachment/0124/8297/0d15b85d-1abf-3967-bf03-3586f5c11f3d.png[/img]

/* @see BufferedReader
 * @see   LineNumberReader
 * @see CharArrayReader
 * @see InputStreamReader
 * @see   FileReader
 * @see FilterReader
 * @see   PushbackReader
 * @see PipedReader
 * @see StringReader
 * @see Writer
 *
 * @author      Mark Reinhold
 * @since       JDK1.1
 */
public abstract class Reader implements Readable, Closeable {

[img]http://dl2.iteye.com/upload/attachment/0124/8299/54f7a106-1c3b-3f29-9103-643d8c90e021.png[/img]


//RandomAccessFile

/* @author  unascribed
 * @since   JDK1.0
 */
public class RandomAccessFile implements DataOutput, DataInput, Closeable {

[img]http://dl2.iteye.com/upload/attachment/0124/8301/6fdf00e1-573e-36dc-99d6-37e37004c1d5.png[/img]


[img]http://dl2.iteye.com/upload/attachment/0124/8303/8d8a1778-7ead-3872-b8b1-f7ec33b69423.png[/img]