Java基础之IO技术（一）

---恢复内容开始---

　　Java基础中的IO技术可谓是非常重要，俗话说的好，万丈高楼起于垒土之间。所以学习Java一定要把基础学好，今天我们来学习IO技术的基础。

　　IO无非就是输入与输出，而其中处理的数据无非是字符与字节。字符最简单的定义就是这个数据是否是纯文本组成，除此之外所有的都是字节。Java给我们提供了字符和字节的处理，其中字符的处理有Writer和Reader两个抽象父类（分别对应的是写和读），字节的处理有OutputStream和InputStream两个抽象类（分别对应的是写和读）。今天我们就看看字符的处理。

　　字符的处理

　　1.字符的读（FileReader）

　　首先请看一段代码：

import java.io.*;

public class FileReader1 {
    public static void main(String[] args){
        FileReader fr = null;
        try{
            fr = new FileReader("1.txt");
            int ch = 0;
            //read():字符读取，如果已经达到流的结尾，则为-1
            //这个可以作为读取文件结束的条件
            while((ch = fr.read()) != -1){
                //进行强制转换
                System.out.print((char)ch);
            }
            sop("读取结束");

        }catch(FileNotFoundException e){
            sop(e.toString());
        }catch(IOException e){
            sop(e.toString());
        }finally{
            try {
                if(fr != null) {
                    fr.close();
                }
            }catch(IOException e){
                sop(e.toString());
            }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

　　这是文件读取的第一种方法，这种方法是将文件中的数据一个一个的读出来，这样操作比较耗资源，因此有了第二种读取方法，请看下面这段代码。

import java.io.*;

public class FileReader2 {
    public static void main(String[] args){
        FileReader fr = null;
        try{
            fr = new FileReader("1.txt");
            //read(char[] cbuf):将字符读取到数组中
            //这个数组大小1024整数倍
            char[] buff = new char[1024];
            int num = 0;
            while((num = fr.read(buff)) != -1){
                sop(new String(buff, 0, num));
            }

        }catch(FileNotFoundException e){
            sop(e.toString());
        }catch(IOException e){
            sop(e.toString());
        }finally{
            try{
                if(fr != null) {
                    fr.close();
                }
            }catch(IOException e){
                sop(e.toString());
            }
        }

    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

　　这种方法是利用一个数组（这个数组大小一般定义为1024的整数倍），将文件中的数据传入到一个数组中，然后将数组中的数据一次性的处理。显而易见这种方法更好。

　　文件打开是需要关闭的，通过close方法。

　　2.字符的写（FileWriter）

　　首先请看下面一段代码

import java.io.*;

public class FileWriterDemo {
    public static void main(String[] args){
        fileWriter();

    }
    public static void fileWriter(){
        FileWriter fw = null;
        try {
            fw = new FileWriter("1.txt");

            fw.write("asdsadasdafd");
            fw.flush();

            fw.append("
"+123);
            fw.flush();

        }catch(IOException e){
            sop(e.toString());
        }finally{
            try{
                if(fw != null) {
                    fw.close();
                }
            }catch(IOException e){
                sop(e.toString());
            }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

　　首先对象的创立，有多个构造函数。这里我介绍两种，FileWriter(String fileName)和FileWriter(String fileName, boolean append)。在第二个构造函数中有一个布尔型参数，为false就和第一个构造函数一样，每次向目的地中写入数据时都会覆盖原来的数据，若不想覆盖原来的数据，可以使用append方法；为true时，就不会覆盖原来的数据，而是在原数据后面追加数据。

　　文件的写入是通过一个缓冲区（为了解决cpu和硬盘速度并不匹配的问题），因此在写入一段数据后，要通过flush方法刷新缓冲区，将数据送到目的地中（文件）。最后通过close方法关闭资源，在关闭之前也会刷新缓冲区。每次向目的地写入数据时，都会检测是否有目的文件，若没有则创建一个。

　　为提高数据的读写效率，Java中提供了缓冲技术，对原来的FileWriter与FileReader进行修饰，其中涉及到了修饰设计模式，这里就不具体讲解。下面就对缓冲技术进行讲解。

　　3.修饰后的写（BufferedWriter）

　　我们还是来看看具体代码

import java.io.*;

public class BufferedWriterDemo {
    public static void main(String[] args){
        //创建一个字符写入流对象
        FileWriter fw = null;
        BufferedWriter bw = null;
        try{
            fw = new FileWriter("2.txt", true);
            //为提高字符写入的流效率，加入了缓冲技术。
            //只要将需要提高效率的流对象作为参数传递给缓冲区的构造函数
            bw = new BufferedWriter(fw);
            for(int i=0; i<5; i++) {
                bw.write("sdadadas"+i);
                bw.newLine();
            }
            //记住，只要用到缓冲区就要刷新
            bw.flush();

        }catch(IOException e){
            sop(e.toString());

        }finally {
            try{
                //其实关闭缓冲区，就是在关闭与缓冲区关联的流对象
                bw.close();
            }catch(IOException e){
                sop(e.toString());
            }
        }


    }
    private static void sop(Object obj){
        System.out.println(obj);
    }
}

　　这一段知识尽在代码与注释中。其中有一个newLine方法，让我们看看1.8api中解释（写一行行分隔符。 行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符（' n'）字符）。在不同系统中，换行符都不同。而使用了这个方法后，同样的代码不会在不同的系统中出现乱码的问题。

　　最后的close方法，有一个疑问（到底是使用流对象的close方法还是使用缓冲技术的close方法呢），首先我们回到一开始，缓冲技术是用来修饰流操作的，必然他们操作的是流。因此使用其中任何一个close方法都会关闭这个流资源。

　　4.修饰后的读（BufferedReader）

　　请看下一段代码

import java.io.*;

public class BufferedReaderDemo {
    public static void main(String[] args){
        FileReader fr = null;
        BufferedReader br = null;
        try{
            //创建一个读取流对象并与文件关联
            fr = new FileReader("2.txt");
            //为了提高效率，加入了缓冲区技术。将字符读取流对象作为参数传入到缓冲对象的构造函数
            br = new BufferedReader(fr);

            String line = null;
            while((line = br.readLine()) != null){
                sop(line);
            }

        }catch(FileNotFoundException e){
            sop(e.toString());
        }catch(IOException e){
            sop(e.toString());
        }finally {
            try{
                if(br != null){
                    br.close();
                }
            }catch(IOException e){
                sop(e.toString());
            }
        }
    }

    private static void sop(Object obj){
        System.out.println(obj);
    }
}

　　

　　这段知识的原理和上一段的知识类似，就不做具体的解释了。就说说其中的readLine方法，我们来看看api文档，public String readLine()，（读一行文字。 一行被视为由换行符（' n'），回车符（' r'）中的任何一个或随后的换行符终止），也就是说把文件中的一行数据读取出来。

　　我们总结一下字符的体系

/**
 * 读：
 *      Reader
 *          |--FileReader（两种读的方法，资源的关闭）
 *          |--BufferedReader（修饰设计模式，高效的处理方式，readLine方法，close方法关闭资源）
 *
 * 写：
 *      Writer
 *          |--FileWriter（两种构造方法，write方法与append方法，）
 *          |--BufferedWriter（修饰设计模式，高效的处理方式，newLine方法，close方法关闭资源）
 *
 *
 * */

　　今天只讲解了字符的操作，关于字节的操作和其他IO的基础知识，在后面会相应的推出。

---恢复内容结束---