Java 流(Stream)、文件(File)和IO

[---------------------Stream-----------------------]

首先，流是什么？
流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。[左图]

流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。
可以将流想象成一个“水流管道”，水流就在这管道中形成了，自然就出现了方向的概念。
当程序需要从某个数据源读入数据的时候，就会开启一个输入流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个输出流，这个数据源目的地也可以是文件、内存或网络等等。

流有哪些分类？
可以从不同的角度对流进行分类：
1. 处理的数据单位不同，可分为：字符流，字节流
2.数据流方向不同，可分为：输入流，输出流
3.功能不同，可分为：节点流，处理流

1和2都比较好理解，对于根据功能分类的，可以这么理解：
节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。

处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。过滤流是使用一个已经存在的输入流或输出流连接创建的，过滤流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。他们都属于过滤流。

流结构介绍：
Java所有的流类位于java.io包中，都分别继承字以下四种抽象流类型。

	字节流	字节流
输入流	InputStream	Reader
输出流	OutputStream	Writer

1.继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)，如图，深色的为节点流，浅色的为处理流。

2.继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)，如图，深色的为节点流，浅色的为处理流。

常见流类介绍：
节点流类型常见的有：
对文件操作的字符流有FileReader/FileWriter，字节流有FileInputStream/FileOutputStream。

处理流类型常见的有：
缓冲流：缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同事增加了一些新的方法。
　　字节缓冲流有BufferedInputStream/BufferedOutputStream，字符缓冲流有BufferedReader/BufferedWriter，字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法。
　　对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘。所以，在使用字符缓冲流的时候，一定要先flush，然后再close，避免数据丢失。
转换流：用于字节数据到字符数据之间的转换。
　　仅有字符流InputStreamReader/OutputStreamWriter。其中，InputStreamReader需要与InputStream“套接”，OutputStreamWriter需要与OutputStream“套接”。
数据流：提供了读写Java中的基本数据类型的功能。
　　DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，需要“套接”在InputStream和OutputStream类型的节点流之上。
对象流：用于直接将对象写入写出。
　　流类有ObjectInputStream和ObjectOutputStream，本身这两个方法没什么，但是其要写出的对象有要求，该对象必须实现Serializable接口，来声明其是可以序列化的。否则，不能用对象流读写。
　　还有一个关键字比较重要，transient，由于修饰实现了Serializable接口的类内的属性，被该修饰符修饰的属性，在以对象流的方式输出的时候，该字段会被忽略。

Demo
InputStream>FileInputStream[读取文件--字节流]
比如我的D盘有一个文件a.txt

两种读取方式，其一：

import java.io.*;
public class FileInputStream_test {
    public static void main(String[] args) {
        try{
            FileInputStream myflie = new FileInputStream("D:\a.txt"); 
            for(int i=0; i<myflie.available(); i++){
                System.out.print((char)myflie.read());
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

其二：

import java.io.*;
public class FileInputStream_test {
    public static void main(String[] args) {
        try{
            FileInputStream myflie = new FileInputStream("D:\a.txt"); //创建字节输入流 
            byte[] tem = new byte[myflie.available()];//创建一个长度为myflie长的竹筒  
            myflie.read(tem);//“取水” 
            System.out.print(new String(tem));  //取出"竹筒"中(字节),将字节数组转成字符串输入
            myflie.close(); //关闭
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

OutputStream>FileOutputStream[写入文件--字节流]

我D盘没b.txt文件

import java.io.*;
public class FileInputStream_test {
    public static void main(String[] args) {
        try{
              FileOutputStream fo = new FileOutputStream("D:\a.txt");
              byte[] data = "这个例子测试文件写".getBytes("GB2312");
              fo.write(data);
              fo.close();  
              System.out.println("写入成功！");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

Reader>InputStreamReader[字节流转字符流]
作用：
InputStreamReader 将字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码，该解码过程将使用平台默认的字符编码，如：GBK。
构造方法：
InputStreamReader isr = new InputStreamReader(InputStream in);//构造一个默认编码集的InputStreamReader类
InputStreamReader isr = new InputStreamReader(InputStream in,String charsetName);//构造一个指定编码集的InputStreamReader类。
参数 in对象通过 InputStream in = System.in;获得。//读取键盘上的数据。
或者InputStream in = new FileInputStream(String fileName);//读取文件中的数据。可以看出FileInputStream 为InputStream的子类。

方式一:从文件读取

import java.io.*;
public class two {
    public static void main(String[] args) throws IOException {
        try {
            InputStream in = new FileInputStream("D:\demo.txt");//以字节流的方式读取文件的数据。  
            InputStreamReader isr = new InputStreamReader(in);//读取字节流，转换成字符流
            char []cha = new char[1024]; //读取并输出
            isr.read(cha);  
            System.out.println(new String(cha));  
            isr.close(); //关闭流 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

 

方式二：从键盘读取

import java.io.*;
public class two {
    public static void main(String[] args) throws IOException {
        try {
            InputStream in = System.in;//以字节流的方式读键盘输入数据。  
            InputStreamReader isr = new InputStreamReader(in);//读取字节流，转换成字符流
            char []cha = new char[1024]; //读取并输出
            isr.read(cha);  
            System.out.println(new String(cha));  
            isr.close(); //关闭流 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
}
    

Reader>BufferedReader[缓冲区]

. 所属类库：
         java.lang.Object 
              java.io.Reader 
                         java.io.BufferedReader

. 基本概念 ：
           public class BufferedReader   extends Reader

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值足够大。
通常， Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader （如 FileReader 和 InputStreamReader ）。BufferedReader 流能够读取文本行 , 通过向 BufferedReader 传递一个 Reader 对象 , 来创建一个 BufferedReader 对象 , 之所以这样做是因为 FileReader 没有提供读取文本行的功能 .

例子一：

import java.io.*;
class two{
  public static void main(String[] args)throws IOException { 
    BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(System.in));
    System.out.print("请输入一系列文字，可包括空格："); 
    String text =bufferedReader.readLine(); 
    System.out.println("您的文字："+text);
  } 
}

 

Reader>InputStreamReader>FileReader[读取文件--字符流]

主要方法：
int read(); // 读取单个字符。返回作为整数读取的字符，如果已达到流末尾，则返回 -1。
int read(char []cbuf);//将字符读入数组。返回读取的字符数。如果已经到达尾部，则返回-1。

方法一：

import java.io.*;
class two{
  public static void main(String[] args)throws IOException { 
        FileReader fr = new FileReader("D://demo.txt");
        int ch = 0;
        while((ch = fr.read()) != -1){System.out.print((char)ch);}
        fr.close();
    }
 } 

方法二：

import java.io.*;
class two{
  public static void main(String[] args)throws IOException { 
        FileReader fr = new FileReader("D://demo.txt");
        int ch = fr.read();
        System.out.print((char)ch+",");
        int ch1 = fr.read();
        System.out.print((char)ch1+",");
        int ch2 = fr.read();
        System.out.print((char)ch2);
        fr.close();
    }
 } 

Reader>InputStreamReader>FileReader[写入文件--字符流]

构造方法：
FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话，并创建。                           
     如：FileWriter fw = new FileWriter("C:\demo.txt");
FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。
     如：FileWriter fw = new FileWriter("C:\demo.txt",ture); //表示在fw对文件再次写入时，会在该文件的结尾续写，并不会覆盖掉。

主要方法：
void write(String str)   //写入字符串。当执行完此方法后，字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。
viod flush()             //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。
viod close()            //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后，再写入或者刷新的话，会抛IOException异常。

import java.io.*;
class two{
  public static void main(String[] args)throws IOException { 
       /**
         * 创建一个可以往文件中写入字符数据的字符流输出流对象
         * 创建时必须明确文件的目的地. 如果文件不存在，这回自动创建。如果文件存在，则会覆盖。 当路径错误时会抛异常
         * 当在创建时加入true参数，回实现对文件的续写。
         */
        FileWriter fw = new FileWriter("D:\demo.txt",false);
        //调用该对象的write方法，向文件写入字符。其实写入到了临时存储缓冲区中
        fw.write("hello world!
");//windows中的换行为
    unix下为
。
        fw.write("丁少华!");
        fw.flush();// 进行刷新，将字符写到目的地中。关闭流，关闭资源。在关闭前会调用flush方法 刷新缓冲区。关闭后在写的话，会抛IOException
        fw.close();
    }
 } 

参考文献：
http://www.tuicool.com/articles/U7VFFr
http://blog.csdn.net/liuhenghui5201/article/details/8292552
http://m.blog.csdn.net/article/details?id=8276278

[---------------------File-----------------------]

import java.io.*;
public class one {
    public static void main(String args[]) throws IOException{
        //声明一个目录对象
        File d = new File("E:\mytest\xls");
        //创建该目录对象
        d.mkdirs();
        //在该目录下创建一个a.xls文件
        FileOutputStream fis=new FileOutputStream("E:\mytest\xls\a.xls");
        
        //检测d是个路径吗
        Boolean b=d.isDirectory();
        System.out.println(b);
    }
}