Java 之 I/O 系列 01 ——基础

Java 之 I/O 系列 目录

Java 之 I/O 系列 01 ——基础

Java 之 I/O 系列 02 ——序列化（一）

Java 之 I/O 系列 02 ——序列化（二）

整理《疯狂java编程》15章

IO流分为输入流（InputStream）和输出流（OutputStream）两类
按流所处理的数据类型又可以分为字节流和字符流(用于处理Unicode字符数据)两类

字节流主要是由 InputStream和OutputStream作为基类，而字符流主要是由 Reader和Writer作为基类的

节点流(低级流) 和 处理流(高级流):
JAVA使用处理流来包装节点流式一种典型的装饰器设计模式，通过使用处理流来包装不同的节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出功能,这就允许Java应用程序采用相同的代码，透明的方式来访问不同输入\输出设备的数据流。所以处理流也叫做包装流

下图说明相关体系:

文件类：(File):
提供文件操作功能(File可以创建，删除等操作对文件或目录，但是要访问文件内容，就必须用到输入/输出流)

1.创建File类对象:
File f;
f = new File("Test.java");
f = new File("E:\\ex\\","Test.java");

2.将目录也当作文件处理File类中提供了实现目录管理功能的方法:
File path = new File("E:\\ex\\");
File f = new File(path, "Test.java");

方法：
f.getName()：返回文件名 temp.dat
f.getParent()：返回文件所在目录名 data
f.getPath()：返回文件路径 data\temp.dat
f.getAbsolutePath()：返回绝对路径 …\data\temp.dat
f.exists()：文件是否存在
f.canWrite(), f.canRead()：文件是否可写、读
f.isFile(), f.isDirectory()：是否为文件或目录
f.lastModified(), f.length(), f.delete()：文件的最后修改日期、长度；删除文件
f.mkdir(), f.list()：创建一个目录；列出目录下所有的文件

几个例子说明:

 /**
 * FileInputStream 测试
 * @ClassName: fileTest_1
 * @Description:
 * @author xingle
 * @date 2014-4-15 下午3:12:54
 */
 public class fileTest_1 {
     public static void main(String[] str) throws IOException{
         File f = new File("E:\\test.txt");
         FileInputStream fis = new FileInputStream(f);
         byte[] buf = new byte[32];
         int hasRead = 0;
         while((hasRead=fis.read(buf))>0){
             System.out.println(new String(buf,0,hasRead));
         }
         if(fis!=null){
             fis.close();
         }
     }
 }

 /**
  * FileReader 测试
  * @ClassName:
  * @Description:
  * @author xingle
  * @date 2014-4-15 下午2:24:12
  */
 public class fileTest_2 {
     public static void main(String[] args) throws IOException  {
         File f = new File("E:\\test.txt");

         FileReader fr = new FileReader(f);
         char[] cbuf = new char[32];
         int hasRead = 0;
         try {
             while((hasRead = fr.read(cbuf))>0){
                 System.out.println(new String(cbuf, 0, hasRead));
             }
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             if(fr!=null){
                 fr.close();
             }
         }
     }
 }

 /**
  * FileOutputStream 测试
  * @ClassName: fileTest_3
  * @Description: 把一个文件的所有内容写到另外一个文件中
  * @author xingle
  * @date 2014-4-15 下午2:45:25
  */
 public class fileTest_3 {
     public static void main(String[] args) throws IOException  {
         FileInputStream fis = null;
         FileOutputStream fos = null;
         try{
             File fi = new File("E:\\test.txt");
             fis = new FileInputStream(fi);
             File fo = new File("E:\\testout.txt");
             //覆盖写入
             fos = new FileOutputStream(fo);
             //追加写入
             //fos = new FileOutputStream(fo,true);
             //判断是否存在该文件
             if (!fo.exists()) {
                 System.out.println("file is not exist");
                 fi.createNewFile();
             }
             int hasRead = 0;
             byte[] buf = new byte[32];
             while((hasRead=fis.read(buf))>0){
                 fos.write(buf, 0, hasRead);
             }
         }catch(IOException e){
             e.printStackTrace();
         }finally{
             if(fis!=null){
                 fis.close();
             }
             if(fos!=null){
                 fos.close();
             }
         }
     }
 }

 /**
  * 浏览当前目录下的所有文件和目录
  * @ClassName: fileTest_4
  * @Description:
  * @author xingle
  * @date 2014-4-15 下午3:31:22
  */
 public class fileTest_4 {
     public static void main(String[] args){
         File f1 = new File("");
         String path = f1.getAbsolutePath();
         System.out.println("当前路径："+path);
         File f = new File(path);
         File[] fileLs = f.listFiles();

         for(int i=0;i<fileLs.length;i++){
             if(fileLs[i].isDirectory()){
                 System.out.println( "目录-- " + fileLs[i].getName());
             }
             else{
                 System.out.println("文件--"+fileLs[i].getName());
             }
         }
     }
 }

 /**
  * 文件过滤
  * @ClassName: 打印.txt结尾的文件名
  * @Description:
  * @author xingle
  * @date 2014-4-15 下午4:32:45
  */
 public class fileTest_5 {
     public static void main(String[] args){
         File f = new File("E:\\filetest");
         String[] files = f.list(new MyFilter());
         for(String name:files){
             System.out.println(name);
         }
     }
 }

 class MyFilter implements FilenameFilter{
     @Override
     public boolean accept(File dir, String name) {
         return name.endsWith(".txt");
     }

 }

过滤流—缓冲流

类BufferedInputStream和BufferedOutputStream继承FilterInputStream和FilterOutputStream，实现了带缓冲的过滤流，它提供了缓冲机制，把任意的I/O流“捆绑”到缓冲流上，可以提高该I/O流的读取效率，在初始化时，除了要指定所连接的I/O流之外，还可以指定缓冲区的大小。
在读写的同时对数据缓存，这样避免每次读写数据都要进行实际的物理读写操作，在用BufferdOutputStream输出时，数据先输入缓冲区，当缓冲区满的时再写入连接的输出流，可以调用flush()来清空缓冲区。

 /**
  * 文件缓冲流测试
  * @ClassName: fileTest_6
  * @Description:
  * @author xingle
  * @date 2014-4-17 上午8:34:54
  */
 public class fileTest_6 {
     public static void main(String[] args){
         try{
             File fin = new File("E:\\test.txt");
             File fout = new File("E:\\testout.txt");
             BufferedInputStream bufin = new BufferedInputStream(new FileInputStream(fin), 256);
             BufferedOutputStream bufout = new BufferedOutputStream(new FileOutputStream(fout), 256);
             int len;
             byte bArray[] = new byte[256];
             do{
                 len = bufin.read(bArray);
                 bufout.write(bArray, 0, len);
                 System.out.println("len:"+len);
             }while(len==256);
             bufin.close();
             bufout.close();
         }catch (IOException e) {
             throw new RuntimeException();
         }
     }
 }

过滤流—数据流

DataInputStream和DataOutputStream, 继承FilterInputStream和FilterOutputStream，可以用来与计算机无关的格式读写JAVA的基本数据类型以及String对象。

DataInputStream

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataInputStream 对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

readBoolean() 读一字节，非零为真
readByte() 以8位读字节
readChar() 读Unicode字符
readInt() 读整数值
writeChar(int v) 把字符写进输出流
writeLong(long v) 把长整写进输出流
writeInt(int v) 把整数写进输出流

数据输出流可以是一个已经建立好的输入数据流对象,例如网络的连结,文件等。数据流可通过如下方式建立。

DataOutputStream
数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

FileInputStream fis = new FileInputStream("file1.txt");
FileOutputStream fos = new FileOutputStream("file2.txt");
DataInputStream dis = new DataInputStream(fis);
DataOutputStream dos = new DataOutputStream(fos);

 /**
  * 过滤流—数据流 ：DataInputStream 和 DataOutputStream 测试
  * @ClassName: fileTest_7
  * @Description:
  * @author xingle
  * @date 2014-4-17 下午5:53:03
  */
 public class fileTest_7 {
     public static void main(String[] args) throws IOException{
         FileOutputStream fos = new FileOutputStream("D:\\test\\2.txt");
         DataOutputStream dos = new DataOutputStream(fos);
         try{
             dos.writeBoolean(true);
             dos.writeByte((byte)123);
             dos.writeChar('J');
             dos.writeDouble(3.1415926);
             dos.writeFloat(2.71f);
             dos.writeInt(1234556);
             dos.writeLong(998877665544332211L);
             dos.writeShort((short) 11223);
         }finally{
             dos.close();
         }
         FileInputStream fis = new FileInputStream("D:\\test\\2.txt");
         DataInputStream dis = new DataInputStream(fis);
         try{
              System.out.println("\t " + dis.readBoolean());
              System.out.println("\t " + dis.readByte());
              System.out.println("\t " + dis.readChar());
              System.out.println("\t " + dis.readDouble());
              System.out.println("\t " + dis.readFloat());
              System.out.println("\t " + dis.readInt());
              System.out.println("\t " + dis.readLong());
              System.out.println("\t " + dis.readShort());
         }finally{
             dis.close();
         }
     }

 }