IO知识点总结2

IO（Input Output）流：

IO流用来处理设备之间的数据传输，java对数据的操作是通过流的方式，java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流。

字节流的抽象基类：InputStream（读），OutputStream（写）

字符流的抽象基类：Reader，Writer

流按流向分为：输入流，输出流。

国际码表：unicode（无论什么字符，2个字节，16个2进制位）------升级-----utf—8

中    国：GB2312----扩容----GBK

FileWriter：专门用于才做文件的子类对象，后缀名是父类名，前缀是其功能！

FileWriter fw = new FileWriter("demo.txt");             

//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。

//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。

//其实该步就是在明确数据要存放的目的地。

fw.flush();

刷新流对象中的缓冲中的数据。

将数据刷到目的地中。

fw.close();

关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。

将数据刷到目的地中。

和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。

FileWriter("demo.txt",true);传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

FileReader fr = new FileReader("demo.txt");

创建一个文件读取流对象，和指定名称的文件相关联。

要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException

read():一次读一个字符。而且会自动往下读。

作为整数读取的字符—读取的字符的个数，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 。

Eg：读取相应文件

import java.io.*;

class FileReaderDemo3

{

    public static void main(String[] args)throws IOException

    {

       FileReader fr=new FileReader("file1.txt");

       char[] chs=new char[3];

       int num=0;

       while((num=fr.read(chs))!=-1)

       {

           System.out.print(new String(chs,0,num));

       }

    }

}

Eg：复制一个文本文件：

import java.io.*;

class Copytest2

{

    public static void main(String[] args)

    {

       FileWriter fw=null;

       FileReader fr=null;

       try

       {

            fw=new FileWriter("filecopy3.txt");

           fr=new FileReader("FileWriterDemo.java");

           char[] chs=new char[1024];

           int num=0;

           while((num=fr.read(chs))!=-1)

           {

              fw.write(chs,0,num);//读到几个数据写几个数据

           }

       }

       catch(IOException e)

       {

           throw new RuntimeException(“读写失败”);

       }

       finally

       {

           try

           {

              if(fw!=null)

              fw.close();

           }

           catch(IOException e)

           {

              throw new RuntimeException();

           }

           try

           {

              if(fr!=null)

              fr.close();

           }

           catch(IOException e)

           {

              throw new RuntimeException();

           }

       }

    }

}

字符流缓冲区（原理就是封装了数组）：

缓冲区的出现提高了对数据的读写效率；

对应类BufferedReader【后缀父类，前缀功能】和BufferedWriter，缓冲区要结合流才可以使用，在流的基础上对流的功能进行了加强。

缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区之前，必须要先有流对象！

只要用到缓冲区，就要记得刷新。

其实关闭缓冲区，就是关闭缓冲区中的流对象。

BufferedWriter：newLine（）：跨平台的换行符

BufferedReader：readLine（）：一下读一行；若读完返回的是null；

readLine（ ）方法返回的时候只返回回车符之前的数据内容，并不返回回车符!

装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有的对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

MyReader//专门用于读取数据的类。

    |--MyTextReader

       |--MyBufferTextReader

    |--MyMediaReader

       |--MyBufferMediaReader

    |--MyDataReader

       |--MyBufferDataReader

 

class MyBufferReader

{

    MyBufferReader(MyTextReader text)

    {}

    MyBufferReader(MyMediaReader media)

    {}

}

上面这个类扩展性很差。

找到其参数的共同类型。通过多态的形式。可以提高扩展性。

 

class MyBufferReader extends MyReader

{

    private MyReader r;

    MyBufferReader(MyReader r)

    {}

}  

MyReader//专门用于读取数据的类。

    |--MyTextReader

    |--MyMediaReader

    |--MyDataReader

    |--MyBufferReader

以前是通过继承将每一个子类都具备缓冲功能。

那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。

将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。

这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。

而且降低了类于类之间的关系。

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

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

LineNumberReader（带着行号读取）：setLineNumber（ ），getLineNumber（）；

字节流：InputStream，OutputStream

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 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();

      

    }

 

字节流的缓冲区：BufferedInputStream和BufferedOutputStream

自定义字节流缓冲区：

import java.io.*;

 

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对象读取硬盘上数据，并存储buf中。

       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();

    }

}

 

读取转换流：

InputStreamReader：字节流转字符流

       获取键盘录入对象。

       InputStream in = System.in;

       将字节流对象转成字符流对象，使用转换流。InputStreamReader

       InputStreamReader isr = new InputStreamReader(in);

       为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

       BufferedReader bufr = new BufferedReader(isr);

       键盘的最常见写法。

       BufferedReader bufr =

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

OutputStreamWriter：

流总结：

通过三个明确来完成。

 

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，那么就将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 bufw = new BufferedWriter(fw);

 

    **************

    扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

   

    目的：OutputStream  Writer

    是否是存文本？是！Writer。

    设备：硬盘。一个文件。使用 FileWriter。

    但是FileWriter是使用的默认编码表。GBK.

   

    但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。

    所以要使用的对象是OutputStreamWriter。

    而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

 

    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

 

    需要高效吗？需要。

    BufferedWriter bufw = new BufferedWriter(osw);

 

    所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，

    需要用到转换流。

 

异常的日志信息：

import java.io.*;

import java.util.*;

import java.text.*;

class  ExceptionInfo

{

    public static void main(String[] args)throws IOException

    {

       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);

       }

    }

}

//log4j：专门用来创建日志信息！