黑马程序员——java学习11（毕18--19）——IO_1

1、IO流

处理设备之间的数据传输

字符流为了处理文字而存在，基于字节流，其中融合了编码表

(1)字节流的抽象基类

InputString        OutputStream

(2)字符流的抽象基类

Reader              Writer

1.1、字符流Writer--------write,flush,close

java.util.FileWriter

FileWriter(String fileName)根据给定的文件名构造一个FileWriter对象

java.io.OutputStreamWriter

void write(String str, int off, int len)将数据写入流中

void flush()刷新流中的缓冲

void close()关闭此流，但要先刷新它

import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符流和字节流
 * 
 * 字节流两个基类
 * InputStream OutputStream
 * 
 * 字符流两个基类
 * Reader Writer
 * 
 * 先学习一下字符流的特点
 * 既然IO流是用于操作数据的
 * 那么数据的最常见体现形式是文件
 * 
 * 那么先以操作文件为主来演示
 * 需求： 在硬盘上，创建一个文件并写入一些文字数据
 * 
 * 找到一个专门用于操作文件的Writer子类对象，FileWriter。后缀名是父类名，前缀名是该流对象的功能
 * */
public class FileWriterDemo {
    public static void main(String[] args) throws IOException{
        //创建一个FileWriter对象，该对象以被初始化就必须要明确被操作的文件
        //而且该文件会被创建到制定目录下，如果该目录下已有同名文件，会被覆盖
        //其实就是明确数据要存放的目的地
        FileWriter fw = new FileWriter("demo.txt");
        
        //调用write方法，将字符串写入到流中
        fw.write("abcde");
        
        //刷新流对象中的缓冲中的数据
//        fw.flush();
        
        
        //关闭流资源，但是关闭之前会刷新一次内部缓冲数据
        //将数据刷到目的地中，和flush的区别在于
        //和flush区别，flush刷新后，流可以继续使用，close刷新后会将流关闭
        fw.close();
    }
    
}

运行结果

1.2、异常处理机制

注意close放入finally，但是也需要排除流创建失败带来的空指针异常，因此需要一个判断

package learn;

import java.io.FileWriter;
import java.io.IOException;

/*IO异常的处理方式
 * 
 * */
public class FileWriterDemo2 {
    public static void main(String[] args) {
            FileWriter fw =null;//对象的建立和引用的挂钩分开写
        try
        {
            //fw创建失败则不可能添加数据，故放在一个try中
             fw = new FileWriter("demo.txt");
            fw.write("abcdefg");
        
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        //必须要关闭流，所以必须写finally,
        //但是因可能出现没流建立成功，没流能关闭，所以也将关闭写作异常
        //finally的执行也需要 fw不为空时才可以
        finally
        {
            try
            {    
                if(fw!=null)
                fw.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
            
        }
        
    }
}

运行结果

1.3、文件的续写

java.io.FileWriter

FileWriter(String fileName, boolean append)根据指定的文件名以及指示是否附加写入数据的boolean值得来构造FileWriter对象。true则在末尾处添加

windows中的换行符为/r/n，因而只写/n得到的是黑块

package learn;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 演示对已有文件的数据续写
 * */
public class FileWriterDemo3 {
    public static void main(String[] args) throws IOException{
        //传递一个true参数，代表不覆盖已有的文件，并在已有文件末尾处进行数据续写
        FileWriter fw= new FileWriter("demo.txt",true);
        fw.write("ha
ha");
        fw.close();
    }
}

运行结果

2.1、字符流Reader 

文本读取方式一

java.io.Reader

int read() 读取单个字符，一直读下去的话，末尾返回值为-1

package learn;

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

public class FileReadDemo {
    public static void main(String[] args) throws IOException{
        //创建一个文件读取流对象，和指定名称的文件相关联
        //要保证文件是已经存在的，如果不存在，会发生异常FileNotFoundException
        FileReader fr = new FileReader("demo.txt");
        //调用读取流对象的read方法
        //read方法一次读一个字符，且会自动往下读
        int ch = 0;
        while((ch=fr.read())!=-1)
        {
            System.out.println((char)ch);
        }
        fr.close();        
    }
}

运行结果

2.2、文本读取方式二

先创建一个数组，读一个存一个，读完了，输出。

java.lang.String

String(int[] codePoints, int offset, int count)分配一个新的String, 它包含Unicode代码点数组参数一个子数组的字符

offset初始偏移量， count长度，（长度即为下例中的num）

package learn;

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

public class FileReadDemo2 {
    public static void main(String[] args) throws IOException{
        FileReader fr = new FileReader("demo.txt");
        //定义一个字符数组，用于存储读到字符
        //该read(char[])返回的是读到字符个数
        //通常定义new char[1024];
        //创建字符数组，大小为3
        char[] buf = new char[3];
        int num = 0;
        //读一个存一下
        while((num = fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }
//        int num = fr.read(buf);
//        System.out.println("num="+num+"..."+new String(buf));
        fr.close();
    }
}

运行结果

2.2.1、练习

当文件内容超过了1024，才会出现println的换行

package Test;

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

/*读取一个.java文件，并打印在控制台上*/
public class FileReaderTest {
    public static void main(String[] args) throws IOException{
        FileReader fr = new FileReader("FileReadDemo.java");
        char[] buf = new char[1024];
        int num = 0;
        while((num = fr.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,num));
        }
        fr.close();
    }
}

运行结果

2.3、copy

copy2更好

思路：有了存放的地方，先读，临时存放下，再一起写入

package Test;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 将C盘一个文本文件复制到D盘
 * 复制的原理：
 * 其实就是将C盘下的文件数据存储到D盘的一个文件中
 * 
 * 步骤：
 * 1、在D盘创建文件。用于存储C盘文件中的数据
 * 2、定义读取流和C盘文件关联
 * 3、通过不断你的读写完成数据存储
 * 4、关闭资源
 * */
public class CopyText {
    public static void main(String[] args) throws IOException {
        copy2();
    }
    //从c盘读一个字符写一个字符
    public static void copy1 ()throws IOException
    {
        //创建目的地
        FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
        //与已有文件关联
        FileReader fr = new FileReader("FileReadDemo.java");
        int ch = 0;
        //有一个字符写一次
        while((ch=fr.read())!=-1)
        {
            fw.write(ch);
        }
        fw.close();
        fr.close();
        
    }
    public static void copy2()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("SystemDe_copy2.txt");
            fr = new FileReader("FileReadDemo.java");
            char[] buf= new char[1024];
            int len = 0;
            while((len=fr.read(buf))!=-1)
            {
                fw.write(buf,0,len);
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            if(fr!=null)
            try
            {
63                 fr.close();
            }
            catch(IOException e)
            {
            }
            if(fw!=null)
            try
            {
                fw.close();
            }
            catch(IOException e)
            {
            }
            }
        }
    }

运行结果

3、字符流的缓冲区

3.1、BufferedWriter

java.io.BufferedWriter

void newLine();写入一个换行符，通用于各操作系统，在win中换成 ,在linux中换成

因为有流才会有缓冲区，故其构造函数都带有参数

package learn;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 缓冲区的出现时为了提高流的操作效率而出现的
 * 所以在创建缓冲区之前，必须要先有流对象
 * 该缓冲区中提供了跨平台的换行符newLine();
 * */
public class BufferedWriterDemo {
    public static void main(String[] args)throws IOException {
        //创建字符写入流对象
        FileWriter fw = new FileWriter("buf.txt");
        //为了提高字符写入流效率，加入了缓冲技术
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
        BufferedWriter bufw = new BufferedWriter(fw);
        for(int x=1;x<5;x++)
        {
            bufw.write("abcd"+x);
            bufw.newLine();
            bufw.flush();
        }
        
        //记住，只要用到缓冲区就要记得刷新
        //其实关闭缓冲区就是在关闭缓冲区中的流对象
        bufw.flush();
        bufw.close();
        
    }
}

运行结果

3.2、BufferedReader

java.io.BufferedReader

String readLine()读取文本下一行

package learn;
/*
 * 字符流取流缓冲区:
 * 该缓冲区提供了一个一次读一行的方法readLine, 方便于对文本数据的获取。
 * 当返回null时，表示读到文件末尾。
 * */
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {
     public static void main(String[] args) throws IOException{
        //创建一个读取流对象和文件相关联
         FileReader fr = new FileReader("buf.txt");
         //为了提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数
         BufferedReader bufr = new BufferedReader(fr);
         String line = null;
         while((line=bufr.readLine())!=null)
         {
             System.out.println(line);
         }
//         String s1 = bufr.readLine();
//         System.out.println("s1:"+s1);
         bufr.close();
         
    }
}

运行结果

3.2.2练习 通过缓冲区复制文件

readLine不返回回车符，即会卡在一行所以在write时须加newLine();

package learn;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 通过缓冲区复制一个java文件
 * readLine不返回车符
 * */
public class CopyTextByBuf {
    public static void main(String[] args) {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;
        try
        {
            bufr = new BufferedReader(new FileReader("FileReadDemo.java"));
            bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
            String line =null;
            while((line=bufr.readLine())!=null)
            {
                bufw.write(line);
                //不加就在一行
                bufw.newLine();
                bufw.flush();
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("读写失败");
        }
        finally
        {
            try
            {
                if(bufr!=null)
                    bufr.close(); 
            }
            catch(Exception e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufr.close(); 
            }
            catch(Exception e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

运行结果

3.3、自写ReadLine

注意，如果原文件结尾没有换行符，则会导致最后一行进入了缓冲区却没被刷入流中，

通过判断缓冲区是否为空来返回至流中

package learn;

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

/*
 * 明白了BufferedReader类中特有方法readLine的原理后，
 * 可以自定义一个类包含一个功能和readLine一致的方法
 * 来模拟一下BufferedReader
 * */
class MyBufferedReader
{    
    private FileReader r;
    MyBufferedReader(FileReader r)
    {
        this.r=r;
    }
    //可以一次读一行的方法
    public String myReadLine() throws IOException
    {
        //定义一个临时容器，源BufferReader封装的是字符数组
        //为了掩饰方便，定义一个StringBuilder容器。因为最终还是要将数据变成字符串
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch=r.read())!=-1)
        {
            //是
则继续往ch里添加下一个字符，而不添加
            //是
则返回toString,
            //不然就是其他字段，则继续往缓冲区sb里添加
            if(ch=='
')
                continue;
            if(ch=='
')
                return sb.toString();
            else
            sb.append((char)ch);
        }
        //如果没有换行符，则数据被读取，放入了缓冲区，没刷到流中
        if(sb.length()!=0)
            return sb.toString();
        return null;
    }
    public void myclose()throws IOException
    {
        r.close();
    }
}
public class MyBufferedReaderDemo {
    public static void main(String[] args) throws IOException{
        FileReader fr = new FileReader("buf.txt");
        MyBufferedReader myBuf = new MyBufferedReader(fr);
        String line = null;
        while((line = myBuf.myReadLine())!=null)
        {
            System.out.println(line);
        }
        myBuf.myclose();
    }
}

运行结果

3.4、装饰设计模式

比继承灵活，避免了体系臃肿，降低了类与类之间的关系

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能

所以装饰类和被装饰类通常是都属于一个体系中的

package learn;
/*
 * 装饰设计模式
 * 当想要对已有的对象进行功能增强时，
 * 可以定义类，将已有对象传入，基于已有的功能，并提供加强功能
 * 那么自定义的该类称为装饰类
 * Person和SuperPerson同属于一个接口/类
 * 装饰类通常会通过构造函数接受被装饰的对象
 * 并基于被装饰的对象的功能，提供更强的功能
 * */

class Person{
    public void chifan(){
        System.out.println("吃饭");
    }
}

class SuperPerson{
    private Person p;
    SuperPerson(Person p)
    {
        this.p=p;
    }
    public void superChifan()
    {
        System.out.println("开胃酒");
        p.chifan();
        System.out.println("甜点");
        System.out.println("来一根");    
    }
}
public class PersonDemo {
    public static void main(String[] args) {
        Person p =new Person();
        //p.chifan();
        SuperPerson sp = new SuperPerson(p);
        sp.superChifan();
    }
}

3.5、LineNumberReaderDemo

切记，注意类名。。。。

（因类名和包名冲突导致包调入失败等等引发的一系列明明没错却显示错误BUG。。。。）

package learn;

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;




public class LineNumberReaderDemo {
    public static void main(String[] args)throws IOException {
        FileReader fr = new FileReader("FileReadDemo.java");
        LineNumberReader lnr = new LineNumberReader(fr);
        String line = null;
        lnr.setLineNumber(100);
        while((line=lnr.readLine())!=null)
        {
            //添加行号
            System.out.println(lnr.getLineNumber()+":"+line);
        }
        lnr.close();
    }
}

运行结果

3.5.2、自己写LineNumberReader

package learn;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

class MyLineNumberReader
{
    private Reader r;
    private int lineNumber;
    MyLineNumberReader(Reader r)
    {
        this.r=r;
    }
    public String myReadLine()throws IOException
    {
        lineNumber++;
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch=r.read())!=-1)
        {
            if(ch=='
')
                continue;
            if(ch=='
')
                return sb.toString();
            else
                sb.append((char)ch);
        }
        if(sb.length()!=0)
            return sb.toString();
        return null;
    }
    public void setLineNumber(int lineNumber)
    {
        this.lineNumber = lineNumber;
    }
    public int getLineNumber()
    {
        return lineNumber;
    }
    public void myClose() throws IOException
    {
        r.close();
    }
}
public class MyLineNumberReaderDemo {
    public static void main(String[] args) throws IOException{
        FileReader fr = new FileReader("FileReadDemo.java");
        MyLineNumberReader mylnr = new MyLineNumberReader(fr);
        String line = null;
        while((line=mylnr.myReadLine())!=null)
        {
            System.out.println(mylnr.getLineNumber()+"::"+line);
        }
        mylnr.myClose();
    }
}

运行结果

4、字节流

4.1、FileInputStream

FileInputStream(File file)

int available()返回流中的字节数，包括

准确的流中内容大小，因此可以替代1024

package learn;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/* 字符流
 * FileReader
 * FileWriter
 * 字节流
 * InputStream
 * OutputStream
 * 需求：想操作图片数据，这是要用到字节流
 * */
public class FileStreamDemo {
    public static void main(String[] args) throws IOException{
//        writeFile();
        readFile_3();
    }
    public static void readFile_3()throws IOException
    {
         FileInputStream fis = new FileInputStream("fos.txt");
//         int num = fis.available();
         //定义一个刚刚好的缓冲区
         
         byte[]buf = new byte[fis.available()];
//         System.out.println(num);
         fis.read(buf);
         System.out.println(new String(buf));

         fis.close();
    }
    public static void readFile_2()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf))!=-1)
        {
            System.out.println(new String(buf,0,len));
        }
        fis.close();
    }
    public static void readFile_1()throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");
        int ch = 0;
        while((ch=fis.read())!=-1)
        {
            System.out.println((char)ch);
        }
        fis.close();
    }
    public static void writeFile() throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");
        fos.write("abcde".getBytes());
        fos.close();
    }
}

运行结果

4.2、复制图片

思路：

java.io.FileInputStream

int read (byte[] b) 返回长度，存入b

图片文件→

fis→len获得fis的read返回的长度，()中的buf暂时存放数据,不是-1就一直存→

fos的write写出长度0-len的数组buf中的数据

package learn;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 复制一个图片
 * 思路：
 * 1、用字节读取流对象和图片关联
 * 2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
 * 3、通过循环读写，完成数据的存储
 * 4、关闭资源
 * */
public class CopyPic {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        FileInputStream fis = null;
        try
        {
            fos = new FileOutputStream("c:\2.bmp");
            fis = new FileInputStream("c:\1.bmp");
            
            byte[]  buf = new byte[1024];
            int len = 0;
            while((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        catch(IOException e)
        {
            throw new RuntimeException("复制文件失败");
        }
        finally
        {
            try
            {
                if(fis!=null)
                    fis.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }

            try
            {
                if(fos!=null)
                    fos.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
            
        }
    }
}

运行结果

4.3、复制MP3

package learn;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*演示mp3的复制，通过缓冲区
 * BufferedOutputStream
 * BufferedInputStream
 * 
 * */
public class CopyMp3 {
    public static void main(String[] args)throws IOException {
        long start = System.currentTimeMillis();
        copy_1();
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"毫秒");
    }
    //通过字节流的缓冲区完成复制
    public static void copy_1()throws IOException{
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\3.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\4.mp3"));
        int by = 0;
        while((by=bufis.read())!=-1)
        {
            bufos.write(by);
        }
        bufis.close();
        bufos.close();
        

    }
}

运行结果

4.3.2、自写

read方法在做提升，一个字节读成4个字节，前面添加0，防止第一个数为-1

write在做强转，把最低8位写出去。

  11111111 11111111 11111111 11111111

&00000000 00000000 00000000 11111111

--------------------------------------------

  00000000 00000000 00000000 11111111

package learn;

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

public class MyBufferedInputStream {
    private InputStream in;
    private byte[] buf = new byte[1024*4];
    private int pos = 0,count = 0;
    MyBufferedInputStream(InputStream in)
    {
        this.in = in;
    }
    //一次读一个字节，从缓冲区(字节数组)获取
    public int myRead()throws IOException
    {
        //通过in对象读取硬盘上数据，并存储到Buffer
        if(count ==0)
        {
            count = in.read(buf);
            if(count<0)
                return -1;
            pos=0;
            byte b =buf[pos];
            count--;
            pos++;
            return b&255;
        }
        else if(count>0)
        {
            byte b =buf[pos];
            count--;
            pos++;
            return b&0xff;
        }
        return -1;
    }
    public void myClose() throws IOException
    {
        in.close();
    }
    
}

运行结果

配合Copymp3后得

4.4、键盘录入

关键语句：

InputStream in = System.in;

package learn;

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

/*读取键盘录入
 * System.out对应的是标准输出设备，控制台
 * System.in对应的是标准输入设备，键盘
 * 需求：通过键盘录入数据，
 * 当录入一行后，就将数据打印，
 * 若录入over，那么停止录入
 * */
public class ReadIn {
    public static void main(String[] args) throws IOException{
        InputStream in = System.in;
        StringBuilder sb = new StringBuilder();
        
        while(true)
        {
            int ch = in.read();
            if(ch=='
')
                continue;
            if(ch=='
')
            {
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0, sb.length());
            }
            else
                sb.append((char)ch);
        }
        
//        System.out.println('
'+0);
//        System.out.println('n'+0);
//        int by = in.read();
//        System.out.println(by);
    }
}

运行结果

4.4.2、转换流--键盘录入

InputStreamReader 字节流通向字符流的桥梁

InputStreamReader(InputStream in);传入参数字节流，创建一个字符集

package learn;

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

public class TransStreamDemo {
    public static void main(String[] args) throws IOException{
        //获取键盘录入对象
        InputStream in = System.in;
        //将字节流对象转成字符流对象，使用转换流InputStreamReader
        InputStreamReader isr = new InputStreamReader(in);
        //为了提高效率，将字符流进行缓冲区技术
        BufferedReader bufr = new BufferedReader(isr);
        String line = null;
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            System.out.println(line.toUpperCase());
        }
        bufr.close();
    }
}

运行结果

4.4.3、键盘录入最常见写法

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

package learn;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class TransStreamDemo {
    public static void main(String[] args) throws IOException{
//        //获取键盘录入对象
//        InputStream in = System.in;
//        //将字节流对象转成字符流对象，使用转换流InputStreamReader
//        InputStreamReader isr = new InputStreamReader(in);
//        //为了提高效率，将字符流进行缓冲区技术
//        BufferedReader bufr = new BufferedReader(isr);
        
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        
//        OutputStream out = System.out;
//        OutputStreamWriter osw = new OutputStreamWriter(out);
//        BufferedWriter bufw = new BufferedWriter(osw);
        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();
        }
        bufr.close();
    }
}

4.5、IO流使用思路

与setIn,setOut方法

/*1、
 * 源：键盘录入
 * 目的：控制台
 * 2、
 * 需求：想把键盘录入的数据存储到一个文件中
 * 源：键盘
 * 目的：文件
 * system.out换成"out.txt"
 * 
 * 3、
 * 需求：想将一个文件的数据打印在控制台上
 * 源：文件
 * 目的：控制台
 * system.in换成"文件名.类型"
 * 
 * 流操作规律
 * 通过三个明确来完成
 * 
 *  1、明确源和目的
 *      源：输入流 InputStream Reader
 *      目的：输出流 OutputStream Writer
 *  2、操作的数据是否是纯文本
 *        是：字符流
 *        不是：字节流
 *    
 *    3、当体系明确后，再明确要使用哪个具体的对象
 *        源设备：内存，硬盘，键盘
 *        目的设备：内存，硬盘，控制台
 *
 *    需求1.将一个文件中的数据存储到另一个文件中。复制文件
 *        源：因为是源，所以使用读取流，InputStream Reader、
 *        是不是操作文本文件
 *        是！这时就可以选择Reader
 *        这样体系就明确了
 *
 *        接下来明确要使用该体系中的哪个对象
 *        明确设备：硬盘。上一个文件
 *        Reader体系中可以操作文件的对象FileReader
 *
 *        是否需要提高效率：是！加入Reader体系中的缓冲区BufferedReader
 *        FileReader fr = new FileReader("a.txt");
 *        BufferedReader bufr = new BufferedReader(fr);
 *
 *        目的:OutputStream Writer
 *        是否是纯文本
 *        是！Writer
 *        设备：硬盘
 *        Writer可以操作文件的对象FileWriter
 *        是否需要提高效率：是！加入Writer体系中的缓冲区BufferedWriter
 *
 *        FileWriter fw = new FileWriter("b.txt");
 *        BufferedWriter bufw = new BufferedWriter(fw);        
 *        
 *需求2：将键盘录入的数据保存到一个文件中
 *        源：InputStream Reader
 *        是否纯文本？是Reader
 *        设备：键盘。对应的对象是system.in
 *        为了操作键盘的文本数据方便，转成字符流按照字符串操作是最方便的
 *        所以，既然明确了Reader,那么就将System.in转换成Reader
 *        用了Reader体系中的转换流InputStreamReader
 *        
 *        InputStreamReader isr= new InputStreamReader(system.in)
 *
 *        需要提高效率吗？需要BufferedReader
 *        BufferedReader bufr = new BufferedReader(isr);
 *
 *        目的：OutputStream Writer
 *        是否是纯文本？是Writer
 *        设备：键盘。一个文件，使用FileWriter
 *        FileWriter fw= new FileWriter("c.txt");
 *        需要提高效率吗？需要BufferedWriter
 *        BufferedWriter bufw = new BufferedWriter(fw);
 *
 *    扩展：想要把录入的数据按照指定的编码表(utf-8)，将数据存到文件中
 *        目的：OutputStream Writer
 *        是否是纯文本？是Writer
 *        设备：键盘。一个文件，使用FileWriter
 *        但是FileWriter使用的是默认编码表
 *    但是存储时，需要加入指定编码表，而指定的编码表只有转换流可以指定
 *        所以要使用的对象是OutputStreamWriter
 *        而该转换流对象要接受一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream
 *        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
 *        需要高效吗，需要
 *         BufferedWriter bufw = new BufferedWriter(osw);
 *     所以，记住，转换流在涉及到字符编码转换时
 * 需要用到转换流
 *    
 *        
 * */
public class TransStreamDemo {
    public static void main(String[] args) throws IOException{
        System.setIn(new FileInputStream("buf.txt"));
        System.setOut(new PrintStream("zzz.txt"));
        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();
        }
        bufr.close();
    }
}

运行结果

4.6、异常的日志信息

package learn;

import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionInfo {
    public static void main(String[] args) {
        try
        {
            int [] arr = new int[2];
            System.out.println(arr[3]);
        }
        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("exeception.log");
                //字符串写入输出流
                ps.println(s);
                //输出流写入文件
                System.setOut(ps);
                
            }
        catch(IOException ex)
        {
            throw new RuntimeException("日志文件创建失败");
        }
            e.printStackTrace(System.out);
        }
    }
}

运行结果