Day19---IO流

BufferedWriter

缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符：newLine();

import java.io.*;
class BufferedWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个字符写入流对象
        FileWriter fw = new FileWriter("buf.txt");

        //为了提高字符写入流效率，加入了缓冲技术。
        //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
        BufferedWriter bufw = new BufferedWriter(fw);

        bufw.write("asdada");

        //记住，只要用到缓冲区，就要记得刷新。
        bufw.flush();

        //其实关闭缓冲区，就是在关闭缓冲区中的流对象
        bufw.close();
    }
}

BufferedRead

/*
字符读取缓冲区
该缓冲区提供了一个一次读一行的方法。readLine，方便于对文本数据的获取。
当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
*/
import java.io.*;
class BufferedReadDemo
{
    public static void main(String[] args) 
    {
        //创建一个读取流对象和文件相关联
        FileReader fr = new FileReader("buf.txt");

        //为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
        BufferedReader bufr = new BufferedReader(fr);

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.println(line);
        }

        bufr.close();
    }
}

通过缓冲区复制文本文件

/*
通过缓冲区复制一个.java文件
*/
import java.io.*;
class CopyTextByBuf
{
    public static void main(String[] args) 
    {
        BufferedReader bufr = null;
        BufferedWriter bufw = null;

        try
        {
            bufr = new BufferedReader(new FileReader("BufferedWriterDemo.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(IOException e)
            {
                throw new RuntimeException("读取关闭失败");
            }
            try
            {
                if(bufw!=null)
                    bufw.close();
            }
            catch(IOException e)
            {
                throw new RuntimeException("写入关闭失败");
            }
        }
    }
}

• readLine方法的原理：
  无论是读一行，或者读取多个字符。其实最终都是在硬盘上一个一个的读取，所以最终使用的还是read方法一次读一个的方法。

/*
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader
*/
class MyBufferedReader
{
    MyBufferedReader(FileReader r)
    {
        this.r = r;
    }
    //可以一次读一行数据的方法
    public String MyReadLine() throws IOException
    {
        //定义一个临时容器。原BufferedReader封装的是字符数组。
        //为了演示方便。定义一个StringBuilder容器，因为最终还是要将数据变成字符串。
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while((ch=r.read())!=-1)
        {
            if(ch=='\r')
                continue;
            if(ch=='\n')
                return sb.toString();
            else
            sb.append((char)ch);
        } 
        if(sb.length()!=0)
            return sb.toString();
        return null; 
    }

    public void myClose() throws IOException
    {
        r.close();
    }
}

装饰设计模式

• 装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。
• 装饰设计模式的特点：
  装饰类通常会通过构造方法接收被装饰对象，并基于被装饰的对象的功能，提供更强的功能。
• 装饰与继承的区别：
  装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类与类之间的关系。
  装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

/*
练习：模拟一个带行号的缓冲区对象。
*/
import java.io.*;
class MyNumberReader
{
    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='\r')
                continue;
            if(ch='\n')
                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();
    }
}
class MyLineNumberReaderDemo
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = new FileReader("CopyTextByBuf.java");

        MyLineNumberReader mylinr = new MyLineNumberReader(fr);

        String line = null;

        mylinr.setLineNumber(100);

        while((line=mylinr.myReadLine())!=null)
        {
            System.out.println(mylinr.getLineNumber()+":"+line);
        }

        mylinr.close();
    }
}

字节流

/*
字节流：InputStream、OutputStream
需求：想要操作图片数据，这时就要用到字节流
*/
import java.io.*;
class FileStream
{
    public static void main(String[] args) throws IOException
    {
        
    }

    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 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_3() throws IOException
    {
        FileInputStream fis = new FileInputStream("fos.txt");

        //int num = fis.available();
        byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，不用再循环了。

        fis.read(buf);

        System.out.println(new String(buf));

        fis.close();
    }

    public static void writeFile() throws IOException
    {
        FileOutputStream fos = new FileOutputStream("fos.txt");

        fos.write("absds".getBytes());

        fos.close();
    }
}

拷贝图片

/*
复制一个图片
思路：
1、用字节读取流对象和图片关联
2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3、通过循环读写，完成数据的存储。
4、关闭资源。
*/
import java.io.*;
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("写入关闭失败");
            }
        }
    }
}

/*
演示MP3的复制，通过缓冲区
BufferedInputStream
BufferedOutputStream
*/
import java.io.*;
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:\\0.mp3"));
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));

        int by = 0;

        while((by=bufis.read())!=-1)
        {
            bufos.write(by);
        }

        bufos.close();
        bufis.close();
    }
}

键盘录入

/*
读取键盘录入
System.out：对应的是标准输出设备，控制台
System.in：对应的是标准输入设备：键盘。

需求：
通过键盘录入数据。
当录入一行数据后，就将该行数据进行打印。
如果录入的数据是over，那么停止录入。
*/
import java.io.*;
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=='\r')
                continue;
            if(ch=='\n')
            {
                String s = sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0,sb.length());
            }
            else
             sb.append((char)ch);
        }
    }
}

通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。

/*
能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？

readLine方法是字符流BufferedReader类中的方法。

而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流在使用字符流缓存中的readLine方法呢？

*/
import java.io.*;
class TransStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //获取键盘录入对象
        //InputStream in = System.in;

        //将字节流对象转成字符流对象，使用转换流。InputStreamReader
        //InputStreamReader isr = new InputStreamReader(in);

        //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
        //BufferedReader bufr = new BufferedReader(isr);

        //键盘录入最常见写法。
        BufferedReader bufr = 
                    new BufferedWriter(new InputStreamReader(System.in));

        //OutputStream out = System.out;
        //OutputStreamWriter osw = new OutputStreamWriter(out);
        //BufferedWriter bufw = new BufferedWriter(out);
        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();
    }
}

流操作规律

• 流操作的基本规律：
  最痛苦的就是流对象有很多，不知道该用哪一个。
  通过两个明确来完成。
  1、明确源和目的。
   源：输入流。InputStream、Reader
   目的：输出流。OutputStream、Writer
  2、操作的数据是否是纯文本
   是：字符流。
   不是：字节流。
  3、当体系明确后，在明确要使用哪个具体的对象。
   通过设备来进行区分：
    源设备：内存、硬盘、键盘
    目的设备：内存、硬盘、控制台
  扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件zhong
  目的：OutputStream、Writer
  是否存在文本？是！Writer。
  设备：硬盘。一个文件。使用 FileWriter。
  但是FileWriter是使用的默认编码表。GBK。
  但是存储是，需要加入指定编码表utf-8，而指定的编码表只有转换流可以指定。
  所以要使用的对象是OutputStreamWriter。
  而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
  需要高效吗？需要
• 所以，记住。转换流什么时候使用？字符和字节之间的桥梁，通常，涉及到字符编码转换时，需要用到转换流。

异常的日志信息

import java.io.*;
import java.util.*;
import java.text.*;
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("exception.log");
                ps.println(s);
                System.setOut(ps);
            }
            catch(IOException ex)
            {
                throw new RuntimeException("日志文件创建失败");
            }
            e.printStackTrace(System.out);
        }
    }
}
//log4j：日志工具包