java IO流解析（三）

这一节我们来讲Scanner类和PrintWriter类的用法

Scanner类
实例1：从键盘读取

import java.util.Scanner;

public class Demo {
    public static void main(String[] args ) {
        Scanner input = new Scanner(System.in);    
        System.out.println("请输出一个整数：");
        int i = input.nextInt();
        System.out.println("你输入的整数是：" + i);
    }
}

以上演示的只是读取一个整数，当然还有读取浮点数和其他数据类型的方法，比较简单，查看API即可

实例2：从字符串读取

import java.util.Scanner;

public class Demo {
    public static void main(String[] args ) {
        //这里的\r\n是换行符，Linux下其实只用\n即可
        Scanner input = new Scanner("hello\r\nworld\r\n");
        //循环读取，hasNext()方法和集合框架里面的一样使
        while(input.hasNext()) {
            //每次读取一行，别的读取方法见API，比较简单
            String s = input.nextLine();
            System.out.println(s);
        }  
    }
}

实例3：从文件读取

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Demo {
    public static void main(String[] args ) {

        String path = File.separator + "home" + File.separator + "siu" +
                      File.separator + "work" + File.separator + "demo.txt";

        File f = new File(path);
        Scanner input = null;
        try {
            //从文件构造Scanner对象，有可能产生异常
            input = new Scanner(f);
            while(input.hasNext()) {
                String s = input.nextLine();
                System.out.println(s);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            input.close();
        }  
    }
}

这里要注意的是，从文件创建Scanner对象得先要有File对象，当然你可以使用匿名对象来创建

此外，还需捕捉异常和关闭文件流

PrintWriter类
实例4：向文件写入内容

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Demo {
    public static void main(String[] args) {
        String path = File.separator + "home" + File.separator + "siu" +
                      File.separator + "work" + File.separator + "demo.txt";

        //创建文件对象
        File file = new File(path);

        PrintWriter p = null;
        try {
            //此处构造函数还可以传其他对象，具体参考API文档
            p = new PrintWriter(file);

            //向文件写入一行，此外还有print()和printf()方法
            p.println("如果有一天我回到从前");
            p.println("回到最原始的我");
            p.println("你是否会觉得我不错");

            //刷新流
            p.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            p.close();
        }  
    }
}

与PrintWriter类似的还有一个PrintStream类，此处以PrintWriter举例是因为文本文件具有人为可读性

而二进制文件（字节模式）则需要使用专门的程序来读取

可能有人会问：FileOutputStream、 FileWriter都能写文件，那么为何还需要PrintWriter和PrintStream类

如果细看API文档，可以知道前者单纯的字符写入流和字节写入流操作的方式大多用数组进行

对文件的细化处理非常不方便，而PrintWriter和PrintStream则很好的解决了这一问题，提供print()等方法

并且，PrintWriter和PrintStream对于不存在文件对象的情况下会直接创建，如果已有文件对象

它们则会把原有文件给覆盖掉，却没有增加方法

解决这问题也很简单，再看API文档

PrintWriter有一个构造方法PrintWriter(Writer out)，也就是能够传入Writer对象

PrintStream有一个构造方法PrintStream(OutputStream out)，也就是能传入OutputStream对象

因此，我们这样写就可以了

new PrintWriter(new FileWriter(file,true))

new PrintStream(new FileOutputStream(file,true))

既能增加数据，也能更高效的处理文件，见如下代码示范

实例5：实现PrintWriter的数据追加功能

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class Demo {
    public static void main(String[] args) {
        String path = File.separator + "home" + File.separator + "siu" +
                      File.separator + "work" + File.separator + "demo.txt";

        //创建文件对象
        File file = new File(path);
        PrintWriter p = null;
        try {
            //利用FileWriter方式构建PrintWriter对象，实现追加
            p = new PrintWriter(new FileWriter(file,true));
            p.println("尼玛 这一句就是追加的 看到没");

            p.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //我们来小心翼翼的关闭流，好吧^_^
            p.close();
        }
    }
}

看，这样就能实现追加效果了，最后一行便是

System类对IO的支持
实例6：System类中的写入

import java.io.IOException;
import java.io.OutputStream;

public class Demo {
    public static void main(String[] args) {
        //别忘了，OutputStream是所有字节写入流的父类
        OutputStream out = System.out;
        try {
            //写入数据，只能是数组，所以用getBytes()方法
            out.write("Hello，bitch！\r\n".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意，此处正好印证了System.out的覆写行为

如果想学好io，整个io体系中的多态需要了解清楚才能驾轻就熟

实例7：System类中的读取

import java.io.IOException;
import java.io.InputStream;

public class Demo {
    public static void main(String[] args) {
        //别忘了InputStream是所有字节输入流的父类
        InputStream in = System.in;
        System.out.print("请输入文字： ");
        byte[] buf = new byte[1024];
        int len = 0;
        try {
            //将输入的数据保证到数组中，len记录输入的长度
            len = in.read(buf);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //用字符串的方式打印数组中的数据
        System.out.println("你的输入是： " + new String(buf,0,len));
    }
}

看，这样就能从键盘获取内容并且打印了

需要注意的是，这里的数组大小是1024字节

一旦输入的数据超过1024字节，那么超过的内容将被截取掉，所以此程序有局限性

并且，一个中文占两个字节，输入中文有时候会被意外截取掉

相信我，每个程序都是俺亲自编写编译的～！！！

实例8：利用BufferedReader实现对键盘的读取
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Demo {
public static void main(String[] args) {
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
System.out.print(“请输入文本：”);
try {
String str = b.readLine();
System.out.println(“你输入的是：” + str);
} catch (IOException e) {
e.printStackTrace();
}

    //循环读取方式
    /*
    while(true) {
        System.out.print("请输入文本：");
        String str = null;
        try {
            str = b.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //如果输入over就结束循环
        if("over".equals(str)) {
            break;
        }
        System.out.println("你输入的是：" + str);
    }
    */

    try {
        //关闭流，不耐烦的就直接抛
        b.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
这样做相对于上面一个方法的好处是：不用关心数组大小的问题

BufferedReader有一个最重要的方法就是readLine()，每次读取一行