Java IO (二),常见的输入/输出流

摘要：字节流和字符流和和两个抽象类是所有输入流的基类本身并不能创建实例来执行输入但它们将成为所有输入流的模板他们的方法是所有输入流都可用的方法中包含如下三个方法从输入流中读取单个字节返回所读取的字节数据字节数据可直接转换为类型从输入流中读取最多个

InputStream和Reader两个抽象类是所有输入流的基类,本身并不能创建实例来执行输入,但它们将成为所有输入流的模板.他们的方法是所有输入流都可用的方法.

int read() 从输入流中读取单个字节,返回所读取的字节数据(字节数据可直接转 换为int类型).

int read(byte[] b) 从输入流中读取最多b.lenght个字节数据,并将其存贮在数组b中,返回实际读取的字节数.

int read(byte[] b,int off,int len) 从输入流中读取最多的len个字符的数据,并存在数组b中,放入数组b中时,从off的位置开始,返回实际读取的字节数.

int read() 从输入流中读取单个字符,返回所读取的字符数据(字符数可以直接转换为int类型)

int read(char[] cbuf) 从输入流中读取最多的cbuf.length个字符数据,并将其存储在字符数组cbuf中,返回实际读取的字符数.

int read(char cbuf,int off,int len) 从输入流中读取最多len个字符的数据,并将其存在cbuf中,从off位置开始,返回实际的读取的字符数.

使用FileInputStream读取自身

javapublic void readFile() throws IOException {
    //创建字节输入流
    FileInputStream fis = new FileInputStram("FileInputTest.java");
    //创建一个长度为1024的缓冲数组
    byte[] bbuf = new byte[1024];
    //保存实际读取的字节数
    int hasRead = 0;
    //循环读取文件内容
    while ((hasRead = fis.read(bbuf)) > 0) {
       System.out.println(new String(bbuf,0,hasRead));
    }
    //文件IO资源不属于内存资源
    //垃圾回收无法回收该资源
    //必须显式关闭
    fis.close();
}

public void readFile() throws IOException {
    FileReader fr = new FileReader("FileReaderTest.java");
    char[] cbuf = new char[32];
    int hasRead = 0;
    while ((hasRead = fr.read(cbuf)) > 0) {
        System.out.println(new String(cbuf,0,hasRead));
    }
    fr.clse();
}

javapublic void copyFile() throws IOException {
    FileInputStream fis = null;
    FileOutputStream fos = null;

    try {
        fis = new FileInputStream("outfile.txt");
        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.printStatckTrance();
    } finally {
        if (fis != null) {
            fis.close();
        }
        if(fos != null) {
            fos.close();
        }
    }
}

javapublic void out() {
    FileWriter fw = null;
    try {
        fw = new FileWrite("file.txt");
        fw.write("但我不能放歌，
");
        fw.write("悄悄是别离的笙箫；
");
        fw.write("夏虫也为我沉默，
");
        fw.write("沉默是今晚的康桥！
");
    } catch (IOException ioe) {

    } finally {
        if(null != fw) {
            fw.close();
        }
    }
}

javapublic void StringNodeTest() {

    String src = "软泥上的青荇，
"
                +"油油的在水底招摇;
"
                +"在康河的柔波里，
"
                +"我甘心做一条水草。";

    StringReader sr = new StringReader(src);
    char[] cbuf = new char[32];
    int hasRead = 0;
    try {
        while((hasRead =sr.read(cbuf)) > 0) {
            System.out.println(new String(cbuf,0,hasRead));
        }
    } catch (IOException ioe) {
        ioe.
    } finally {
        if (null != sr){
            sr.close();
        }
    }
}

javapublic void convInput() {
    BufferedReader br = null;

    try {
        //System.in转换成Reader对象
        InputStreamReader reader = new InputStreamReader(System.in);
        //将Reader包装成BufferedReader
        br = new BufferedReader(reader);
        String buffer = null;
        While((buffer = br.readLine()) != null) {
            if("exit".equals(buffer)) {
                System.exit(1);
            }
            System.out.println("输入内容为:" + buffer);
        }
    } catach (IOException ioe) {

    } finally {
        try {
            if (null != br) {
                br.close();
            }
        } catach (IOException ioe) {

        }
    }
}

java/**省略无数代码**/

PushbackReader pr = null;

        try {
            pr = new PushbackReader(new FileReader("E:workplace1
eviewsrcioPushbackReaderTest.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.println(new String(buf,0,targetIndex));
                    System.exit(0);
                } else {
                    System.out.println(lastContent);
                    lastContent = content;
                }
            }

/**省略无数代码**/

java/**省略无数代码**/
        PrintStream ps = null;

        try {
            //创建重定向需要的输出流
            ps = new PrintStream(new FileOutputStream("out.txt"));
            //将标准输出流重定向到ps输出流
            System.setOut(ps);
            //测试输出
            System.out.println("普通字符串");
            System.out.println(new RedirectOut());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (null != ps) {
                ps.close();
            }
        }
/**省略无数代码**/

java/**省略无数代码**/
        FileInputStream fis = null;

        try {
            fis = new FileInputStream("E:workplace1
eviewsrcioRedirectIn.java");
            //将标准输入重定向到fis输入流
            System.setIn(fis);
            //获取标准输入
            Scanner sc = new Scanner(System.in);
            //设置只把回车作为分隔符
            sc.useDelimiter("
");
            while (sc.hasNext()) {
                System.out.println("键盘输入内容为:" + sc.next());
            }
/**省略无数代码**/