疯狂java学习笔记1119---转换流

转换流

        转换流用于实现将字节流转换成字符流，其中InputStreamReader将字节输入流转换成字符输入流，OutputStreamWriter将字节输出流转换成字符输出流。（JAVA没有提供将字符流转换成字节流的转换流）

通常规则：如果需要进行输入输出的内容是文本内容，则应该考虑使用字符流，如果需要进行输入输出的二进制内容，则应该考虑使用字节流。
 
      Java使用System.in代表标准输入，即键盘输入，但这个标准输入流是InputStream类的实例，使用不太方便，而且键盘输入的内容都是文本内容，所以我们使用InputStreamReader将
其转换成字符输入流，普通Reader读取输入内容时依然不太方便，我们可以将普通Reader再次包装成BufferdReader,利用BufferdReader的readLine方法可以一次读取一行内容。

 程序范例：

package J1114;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class KeyinTest
{
    public static void main(String[] args)
    {
        BufferedReader br = null;
        try
        {
            //将System.in对象转换成Reader对象
            InputStreamReader reader = new InputStreamReader(System.in);
            //将普通Reader包装成BufferdReader
            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();
            }

        }
    }
}

上面程序中将System.in包装成BufferedReader,BufferdReader流具有一个缓冲功能，
它可以一次读取一行文本-----以换行符为标志，如果它没有读到换行符则程序阻塞，等到读到换行符为止。

 由于BufferedReader具有一个readLine方法，可以非常方便的一次读入一行内容，所以
 经常把读取文本内容的输入流包装成BufferedReader,用以方便的读取输入流的文本内容。

推回输入流

 

package J1119;

import java.io.FileReader;
import java.io.IOException;
import java.io.PushbackReader;

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.println(new String(buf,0,targetIndex));
                    System.exit(0);

                }
                else
                {
                    //打印上次读取的内容
                    System.out.println(lastContent);
                    //将本次内容设为上次读取的内容
                    lastContent = content;
                }
            }
        }
        catch(IOException ioe)
        {
            ioe.printStackTrace();
        }
        finally
        {
            try
            {
                if(pr != null)
                    pr.close();
            }
            catch(IOException ioe)
            {
                ioe.printStackTrace();
            }
        }
    }
}

重定向标准输入/输出

    重定向标准输出

package J1119;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class RedirectOut
{
    public static void main(String[] args)
    {
        PrintStream ps = null;
        try
        {
            //一次性创建PrintStream输出流
            ps = new PrintStream(new FileOutputStream("out.txt"));
            //将标准输入重定向到ps流输出流
            System.setOut(ps);
            //向标准输出输出一个字符串
            System.out.println("普通字符串");
            //向标准输出输出一个对象
            System.out.println(new RedirectOut());
        }
        catch(IOException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if(ps != null)
            {
                ps.close();
            }

        }
    }
}

     上面程序中创建了一个PrintStream输出流，并将系统的标准输出重定向到该PrintStream输出流，运行上面程序看不到任何输出----输出不再输出到屏幕，而是输出到out.txt文件。

重定向标准输入

 

package J1120;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Scanner;

public class RedirectIn
{
    public static void main(String[] args)
    {
        FileInputStream fis = null;
        try
        {
            fis = new FileInputStream("RedirectIn.java");
            //将标准输入重定向到fis输入流
            System.setIn(fis);
            //使用System.in创建Scanner对象，用于获取标准输入
            Scanner sc = new Scanner(System.in);
            //增加下面一行将只把回车作为分隔符
            sc.useDelimiter("\n");
            //判断是否还有下一个输入项
            while(sc.hasNext())
            {
                //输入输出项
                System.out.println("键盘输入的内容是："+ sc.next());
            }
        }
        catch(IOException ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            if(fis != null)
            {
                try
                {
                    fis.close();
                }
                catch(IOException ex)
                {
                    ex.printStackTrace();
                }

            }
        }
    }
}

上面程序中创建了FileInputStream输出流，并使用System的setIn方法将系统标准输入重定向到
该文件输入流。运行上面程序，程序不会等待用户输入，而是直接输出了RedirectIn.java文件
的内容，这表明程序不再使用键盘作为标准输入，而是使用RedirectIn.java文件作为标准输入源。