Java中的IO

原创

wayne2088 2011-01-16 21:45:26 博主文章分类：Java ©著作权

©著作权归作者所有：来自51CTO博客作者wayne2088的原创作品，请联系作者获取转载授权，否则将追究法律责任

输入和输出是所有应用中所必需的组成部分，通过IO可以读取输入数据以及存储数据到外部设备上。Java中的输入和输出是通过java.io来支持的。下面是本人在学习中的归纳和体会。

1. File类和文件过滤器

顾名思义，File类中是有关文件的操作。这里必须明确，文件还包括目录。通过文件或目录路径的字符串作为参数，根据传入的是目录路径还是文件名路径可以分别初始化不同的File对象。在File对象中封装了对文件的操作，例如新建文件，删除文件和重命名等方法。但是它并不能访问文件本身的内容，这需要输入输出流来完成。下面是有关File类的代码。

public class FileTest  
{  
    public static void main(String[] args) throws IOException  
    {  
        //以当前路径来创建一个File对象  
        File file = new File(".");   
        //直接获取文件名，输出一点  
        System.out.println(file.getName());  
        //获取相对路径的父路径可能出错，下面代码输出null  
        System.out.println(file.getParent());  
        //获取绝对路径  
        System.out.println(file.getAbsoluteFile());  
        //获取上一级路径  
        System.out.println(file.getAbsoluteFile().getParent());  
        //在当前路径下创建一个临时文件  
        File tmpFile = File.createTempFile("aaa", ".txt", file);  
        //指定当JVM退出时删除该文件  
        tmpFile.deleteOnExit();  
        //以系统当前时间作为新文件名来创建新文件  
        File newFile = new File(System.currentTimeMillis() + "");  
        System.out.println("newFile对象是否存在：" + newFile.exists());  
        //以指定newFile对象来创建一个文件  
        newFile.createNewFile();  
        //以newFile对象来创建一个目录，因为newFile已经存在，  
        //所以下面方法返回false，即无法创建该目录  
        newFile.mkdir();  
        //使用list方法来列出当前路径下的所有文件和路径  
        String[] fileList = file.list();  
        System.out.println("======当前路径下所有文件和路径如下=====");  
        for (String fileName : fileList)  
        {  
            System.out.println(fileName);  
        }  
      
        //listRoots静态方法列出所有的磁盘根路径。  
        File[] roots = File.listRoots();  
        System.out.println("======系统所有根路径如下=====");  
        for (File root : roots)  
        {  
            System.out.println(root);  
        }  
    }  
}

在上面的代码中，使用list()方法可以返回目录下所有文件的路径和名称。使用文件过滤器，可以根据自己的需要选择返回的文件类型。通过一个实现了FilenameFilter接口的类对象作为list()方法的参数，就可以实现文件过滤的作用。过滤的规则在重写FilenameFilter中的accept()方法中定义。代码如下：

public class FilenameFilterTest  
{  
    public static void main(String[] args)   
    {  
        File file = new File(".");  
        String[] nameList = file.list(new MyFilenameFilter());  
        for (String name : nameList)  
        {  
            System.out.println(name);  
        }  
    }  
}  
//实现自己的FilenameFilter实现类  
class MyFilenameFilter implements FilenameFilter  
{  
    public boolean accept(File dir, String name)  
    {  
        //如果文件名以.java结尾，或者文件对应一个路径，返回true  
        return name.endsWith(".java")  
            || new File(name).isDirectory();  
    }  
}

2. 输入输出流

在Java中，从不同角度定义了输入输出流的分类。以内存作为流的方向基点，可将其分为输入流和输出流，流向内存的成为输入流，流出内存的成为输出流。从数据操作的最小单元来分类，可将其分为字节流和字符流。根据抽象程度分类，可将其分为节点流和处理流，处理流是连接到实际物理节点的节点流的封装，这样既可以不必去关注节点的来源（文件或者数组），用统一的方法去操作，又可以使用更加方面的方法来实现操作。

在学习中，本人对于输入输出流的总结归纳：

A. 字节流和字符流其实并没有本质的区别，无非是它们二者的操作单元不同。字节流的基类为InputStream和OutputStream，字符流的基类为Reader和Writer。它们所提供的读写方法一样，区别在于参数，需要对应流类型。

B. 输入流中的read系列方法是从输入流中读取数据的操作。空参数将返回所读取的字节（字符）。read方法中可以传入数组参数，数组的类型必须和流的数据类型相匹配，相当于一个竹筒，一次可读取最多等于数组容量的数据，并将所读数据装进数组中。

C. 输出流中的write系列方法是向输出流中写入数据的操作。方法中的参数可以是整型或字符型变量，也可以传入数组参数，数组的类型必须和流的数据类型相匹配，相当于一个竹筒，一次可写入最多等于数组容量的数据。特别地，字符型输出流的write方法可以传入字符串。

D. InputStream和OutputStream，Reader和Writer这四个类作为Java中输入输出流的抽象基类，并不能直接被初始化使用。Java中提供了一些继承了它们的类，用于实现具体的某种流操作。如：

a.File前缀系列的类（如FileInputStream），用于对文件类进行流操作，使用文件名作为构造函数的参数；示例代码如下：

输出类：

public class FileOutputStreamTest  
{  
    public static void main(String[] args) throws IOException  
    {  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try 
        {  
            //创建字节输入流  
            fis = new FileInputStream("FileOutputStreamTest.java");  
            //创建字节输入流  
            fos = new FileOutputStream("newFile.txt");  
            byte[] bbuf = new byte[32];  
            int hasRead = 0;  
            //循环从输入流中取出数据  
            while ((hasRead = fis.read(bbuf)) > 0 )  
            {  
                //每读取一次，即写入文件输出流，读了多少，就写多少。  
                fos.write(bbuf , 0 , hasRead);  
            }  
        }  
        catch (IOException ioe)  
        {  
            ioe.printStackTrace();  
        }  
        finally 
        {  
            //使用finally块来关闭文件输入流  
            if (fis != null)  
            {  
                fis.close();  
            }  
            //使用finally块来关闭文件输出流  
            if (fos != null)  
            {  
                fos.close();  
            }  
        }  
    }  
}

输入类：

public class FileInputStreamTest  
{  
    public static void main(String[] args) throws IOException  
    {  
        //创建字节输入流  
        FileInputStream fis = new FileInputStream("FileInputStreamTest.java");  
        //创建一个长度为1024的“竹筒”  
        byte[] bbuf = new byte[1024];  
        //用于保存实际读取的字节数  
        int hasRead = 0;  
        //使用循环来重复“取水”过程  
        while ((hasRead = fis.read(bbuf)) > 0 )  
        {  
            //取出“竹筒”中水滴（字节），将字节数组转换成字符串输入！  
            System.out.print(new String(bbuf , 0 , hasRead ));  
        }  
        fis.close();  
    }  
}

b. 数组前缀系列类（如ByteArrayInputSteam），用于对数组进行流操作，使用数组对象作为构造函数的参数；

c. 转换流InputStreamReader将字节输入流转换为字符输入流；InputStreamReader将字节输出流转换为字符输出流，代码如下：

public class KeyinTest  
{  
    public static void main(String[] args)   
    {  
        BufferedReader br = null;  
        try 
        {  
            //将Sytem.in对象转换成Reader对象  
            InputStreamReader reader = new InputStreamReader(System.in);  
            //将普通Reader包装成BufferedReader  
            br = new BufferedReader(reader);  
            String buffer = null;  
            //采用循环方式来一行一行的读取  
            while ((buffer = br.readLine()) != null)  
            {  
                //如果读取的字符串为"exit"，程序退出  
                if (buffer.equals("exit"))  
                {  
                    System.exit(1);  
                }  
                //打印读取的内容  
                System.out.println("输入内容为:" + buffer);  
            }  
        }  
        catch (IOException ioe)  
        {  
            ioe.printStackTrace();  
        }  
        //关闭输入流  
        finally 
        {  
            try 
            {  
                br.close();               
            }  
            catch (IOException ioe)  
            {  
                ioe.printStackTrace();  
            }  
        }  
    }  
}

d. 字符流的子类有String前缀（StringReader和StringWriter）系列类可以对字符串进行操作，代码如下：

public class StringNodeTest  
{  
    public static void main(String[] args)   
    {  
        String src = "从明天起，做一个幸福的人\n" 
            + "喂马，劈柴，周游世界\n" 
            + "从明天起，关心粮食和蔬菜\n" 
            + "我有一所房子，面朝大海，春暖花开\n" 
            + "从明天起，和每一个亲人通信\n" 
            + "告诉他们我的幸福\n";  
        StringReader sr = new StringReader(src);  
        char[] buffer = new char[32];  
        int hasRead = 0;  
        try 
        {  
            //采用循环读取的访问读取字符串  
            while((hasRead = sr.read(buffer)) > 0)  
            {  
                System.out.print(new String(buffer ,0 , hasRead));  
            }  
        }  
        catch (IOException ioe)  
        {  
            ioe.printStackTrace();  
        }  
        finally 
        {  
            sr.close();  
        }  
        //创建StringWriter时，实际上以一个StringBuffer作为输出节点  
        //下面指定的20就是StringBuffer的初始长度  
        StringWriter sw = new StringWriter(20);   
        //调用StringWriter的方法执行输出  
        sw.write("我远离了大海，\n");  
        sw.write("看不到春暖花开,\n");  
        sw.write("我只有一只小龟，\n");  
        sw.write("一样可以闻到馥郁花香\n");  
        System.out.println("------下面是sw的字符串节点里的内容------:");  
        //使用toString方法返回StringWriter的字符串节点的内容  
        System.out.println(sw.toString());  
    }  
}

d.推回输入流PushbackInputStream和PushbackReader带有一个推回缓冲区，使用unread（数组）方法可以将一个字节/字符数组推回到推回缓冲区中。推回输入流也有read方法，使用read方法读取输入流时，首先从输入缓冲区中读取，读完之后才从输入流中读。代码如下：

public class PushbackTest  
{  
    public static void main(String[] args)   
    {  
        PushbackReader pr = null;  
        try 
        {  
            //创建一个PushbackReader对象，指定推回缓冲区的长度为64  
            pr = new PushbackReader(new FileReader("PushbackTest.java") , 64);  
            char[] buf = new char[32];  
            //用以保存上次读取的字符串内容  
            String lastContent = "";  
            int hasRead = 0;  
            //循环读取文件内容  
            while ((hasRead = pr.read(buf)) > 0)  
            {  
                //将读取的内容转换成字符串  
                String content = new String(buf , 0 , hasRead);  
                int targetIndex = 0;  
                //将上次读取的字符串和本次读取的字符串拼起来，查看是否包含目标字符串  
                //如果包含目标字符串  
                if ((targetIndex = (lastContent + content).indexOf("new PushbackReader")) > 0)  
                {  
                    //将本次内容和上次内容一起推回缓冲区  
                    pr.unread((lastContent + content).toCharArray());  
                    //再次读取指定长度的内容（就是目标字符串之前的内容）  
                    pr.read(buf , 0 , targetIndex);  
                    //打印读取的内容  
                    System.out.print(new String(buf , 0 ,targetIndex));  
                    System.exit(0);  
                }  
                else 
                {  
                    //打印上次读取的内容  
                    System.out.print(lastContent);  
                    //将本次内容设为上次读取的内容  
                    lastContent = content;  
                }  
            }  
        }  
        catch (IOException ioe)  
        {  
            ioe.printStackTrace();  
        }  
        finally 
        {  
            try 
            {  
                if (pr != null)  
                    pr.close();  
            }  
            catch (IOException ioe)  
            {  
                ioe.printStackTrace();  
            }  
        }  
    }  
}

E. 在Java虚拟机中可以通过exec方法执行其他的应用程序，并返回Proess对象。利用该对象的getErrorStream、getInputStream和getOutputStream方法可以分别获得子进程的错误流，输出流和输入流（方向是以程序角度为基点）。

F. RandomAccessFile类提供对文件的随机访问，程序可以直接跳转到文件的任何地方来读取数据。它内部提供了与字节流同法相同的读写方法，另外又加入了自由定位文件记录指针的方法seek。在读写操作时以字节为单位。在构造函数中还需加入一个mode参数由于制定读写权限。

G. 需要注意Scanner对象的使用。Scanner对象用于捕获输入，并将输入内容转换为字符串。

//使用System.in创建Scanner对象，用于获取标准输入  
        Scanner sc = new Scanner(System.in);  
        PrintStream ps = new PrintStream(  
            new FileOutputStream("out.txt"));  
        //增加下面一行将只把回车作为分隔符  
        sc.useDelimiter("\n");  
        //判断是否还有下一个输入项  
        while(sc.hasNext())  
        {  
            //输出输入项  
            ps.println("键盘输入的内容是：" + sc.next());  
        }  
        ps.close();

对于初学者来说一个容易忽略的地方是，需要区别节点流和处理流构造方法中参数的意义。节点流中，构造方法参数是要读取或者输出地物理节点，是“目的地”或者“始发地”，而处理流的构造函数参数是所要包装的处理流对象，包装之后的操作实际上是间接操作节点流，并未对被包装的节点流本身属性做修改。采用处理流包装后，可以不用管节点流的数据类型，而根据处理流的性质传递在节点流中不能传递的内容，例如Obj；同时还可以增加一些便于操作的方法，比如缓冲区。