IO流应用：读取一行数据PrintRowData()、字节流转换为字符流TransStream()、键盘录入最常见写法TransStream2()、键盘录入保存到文件TS_KeyToFile()、获取异常日志信息GetExceptionInfo()、管道流PipedStream()、

//读取一行数据当输入jean时就停止输入退出
    public static void PrintRowData()throws IOException
    {
        InputStream ins =System.in;
        StringBuffer sb =new StringBuffer();
        
        
        while(true)
        {
            int flag =ins.read();
            if (flag=='\r')
                continue;
            if (flag=='\n')
            {
                String s =sb.toString();
                if ("jean".equals(s))
                    break;
                sop(s.toUpperCase());
                sb.delete(0,s.length());
                //sb.deleter(0,sb.length());
            }
            else sb.append((char)flag);
            //sop(sb);
        }
        
    }

//将字节流转换为字符流，就可以使用字符流缓冲区中的readLine方法
    public static void TransStream()throws IOException
    {
        /*InputStream ins =System.in;

        //转换流InputStreamReader
        InputStreamReader insr= new InputStreamReader(ins);

        //提高效率，使用缓冲区技术
        BufferedReader bufr =new BufferedReader(insr); */
        
        //3-->1
        BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
        String line=null;
        while((line=bufr.readLine())!=null)
        {
            if ("jean".equals(line))
                break;
            sop(line.toUpperCase());
        }
        bufr.close();
    }

//键盘录入最常见写法：
    public static void TransStream2()throws IOException
    {
        BufferedReader bufr =new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw =new BufferedWriter(new OutputStreamWriter(System.out));

        String line =null;
        while((line=bufr.readLine())!=null)
        {
            if ("over".equals(line))
                break;
            bufw.write(line.toUpperCase());
            bufw.newLine();
            bufw.flush();
        }
    }

//键盘录入的数据存储到一个文件中
    public static void TS_KeyToFile()
    {
        BufferedReader bufr =null;
        BufferedWriter bufw =null;

        String line =null;
        try
        {
            bufr =new BufferedReader(new InputStreamReader(System.in));
            bufw =new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo.log")));
            while((line=bufr.readLine())!=null)
            {
                if ("end".equals(line))
                    break;
                bufw.write(line);
                bufw.newLine();
                bufw.flush();

            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("存储失败");
        }
        finally
        {
            try
            {
                if (bufr!=null)
                {
                    bufr.close();
                }
            }
            catch (IOException e)
            {
                throw new RuntimeException("源读取失败");
            }
            try
            {
                if (bufw!=null)
                {
                    bufw.close();
                }
            }
            catch (IOException e)
            {
                throw new RuntimeException("文件写入失败");
            }
        }
        
    }

//获取异常日志信息
    public static void getExceptionInfo()
    {
        
        try
        {
            byte [] buf =new byte[2];
            sop(buf[2]);    
        }
        catch (Exception e)
        {
            try
            {
                Date d =new Date();
                SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String s =sdf.format(d);

                PrintStream ps =new PrintStream("exceptionInfo.log");
                ps.println(s);
                System.setOut(ps);//改变标准输出设备
            }
            catch (IOException ex)
            {
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);//记录错误信息
        }
    }

import java.io.*;


class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in)
    {
        this.in =in;
    }

    public void run()
    {
        try
        {
            byte [] buf =new byte[1024];

            System.out.println("读取数据前：没有数据，现在是阻塞状态");
            int len=in.read(buf);

            System.out.println("读取到了数据，数据来了，阻塞结束");
            
            String s =new String(buf,0,len);
            System.out.println(s);
            in.close();
        }
        catch (IOException e)
        {
            throw new RuntimeException("管道读取流失败");
        }
    }
}

class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
        this.out =out;
    }
    public void run()
    {
        try
        {
            
            System.out.println("开始写入数据了，等待3s后开始：");
            Thread.sleep(3000);
            
            out.write("i love you".getBytes());
            out.close();
        }
        catch (Exception e)
        {
            throw new RuntimeException("管道写入流失败");
        }
    }    

}
class  PipedStreamDemo
{
    public static void main(String[] args)throws IOException
    {
        PipedInputStream in =new PipedInputStream();
        PipedOutputStream out =new PipedOutputStream();

        in.connect(out);

        Write w =new Write(out);
        Read r =new Read(in);

        new Thread(r).start();
        new Thread(w).start();
        
    }
}