《黑马程序员》Java IO流

　　——- android培训、java培训、期待与您交流！ ———-
　　
一.字符流
1.Reader
用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
i)BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
ii)LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
iii)InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
iv)FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
v)CharArrayReader：此类实现一个可用作字符输入流的字符缓冲区。
vi)StringReader：其源为一个字符串的字符流。
2.Writer
写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
i)BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
ii)OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
iii)FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
iv)PrintWriter：向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。
v)CharArrayWriter：此类实现一个可用作 Writer 的字符缓冲区。缓冲区会随向流中写入数据而自动增长。可使用 toCharArray() 和 toString() 获取数据。
注：在此类上调用 close() 无效，并且在关闭该流后可以调用此类中的各个方法，而不会产生任何IOException。
vi)StringWriter：一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。关闭 StringWriter 无效。此类中的方法在关闭该流后仍可被调用，而不会产生任何 IOException。
IO中的使用到了一个设计模式：装饰设计模式。
装饰设计模式解决：对一组类进行功能的增强。
包装：写一个类(包装类)对被包装对象进行包装；
* 1、包装类和被包装对象要实现同样的接口；
* 2、包装类要持有一个被包装对象；
* 3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；
二.字节流
InputStream：是表示字节输入流的所有类的超类，具有以下子类对象
i) FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
ii) FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
iii) BufferedInputStream：该类实现缓冲的输入流。
Stream：
ObjectInputStream：
PipedInputStream：
OutputStream：此抽象类是表示输出字节流的所有类的超类。
i)FileOutputStream：文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
ii) FilterOutputStream：此类是过滤输出流的所有类的超类。
iii) BufferedOutputStream：该类实现缓冲的输出流。
iv) PrintStream：
v)DataOutputStream：
vi) ObjectOutputStream：
vii) PipedOutputStream：
三.缓冲流 (BufferedReader BufferedWriter )
1.为什么要引入缓冲流？
目的是为了加快读写速度。
代码示例：
BufferedReader

package day19;/*字符读取流缓冲区：该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。当返回null时，表示读到文件末尾。readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。*/import java.io.*;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.print(line);        }        bufr.close();    }}

BufferedWriter

package day19;/*缓冲区的出现是为了提高流的操作效率而出现的。所以在创建缓冲区之前，必须要先有流对象。该缓冲区中提供了一个跨平台的换行符。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);        for(int x=1; x<5; x++)        {            bufw.write("abcd"+x);            bufw.newLine();            bufw.flush();        }        //记住，只要用到缓冲区，就要记得刷新。        //bufw.flush();        //其实关闭缓冲区，就是在关闭缓冲区中的流对象。        bufw.close();    }}

流对象：其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。
流的操作规律：
1，明确源和目的。
数据源：就是需要读取，可以使用两个体系：InputStream、Reader；
数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；
2，操作的数据是否是纯文本数据？
如果是：数据源：Reader 数据汇：Writer
如果不是：数据源：InputStream 数据汇：OutputStream
3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？明确操作的数据设备。
数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)
数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。
4，需要在基本操作上附加其他功能吗？比如缓冲。如果需要就进行装饰。

四.File类
File类常见方法：
1：创建。
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
boolean mkdir()：创建此抽象路径名指定的目录。
boolean mkdirs()：创建多级目录。
2：删除。
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
3：获取.
long length()：获取文件大小。
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回 null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
4：判断：
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
5：重命名。
boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。
对文件的读写流
i)FileReader

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((ch));        }        fr.close();    }

代码事例如下：
ii)FileWriter
代码示例如下：

public static void main(String[] args) throws IOException    {        //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。        //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。        //其实该步就是在明确数据要存放的目的地。        FileWriter fw = new FileWriter("demo.txt");        //调用write方法，将字符串写入到流中。        fw.write("abcde");        //刷新流对象中的缓冲中的数据。        //将数据刷到目的地中。        //fw.flush();        //关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。        //将数据刷到目的地中。        //和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。        fw.close();    }

下面对字节流与字符流进行小结：
字符流和字节流：
字节流两个基类：
InputStream OutputStream
字符流两个基类：
Reader Writer
先学习一下字符流的特点。
既然IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。
那么先以操作文件为主来演示。
需求:在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象。FileWriter。 后缀名是父类名。 前缀名是该流对象的功能。
五.其他流
1：SequenceInputStream
序列流，作用就是将多个读取流合并成一个读取流。实现数据合并。
表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。
该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对象。
但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。
合并原理：多个读取流对应一个输出流。
切割原理：一个读取流对应多个输出流。
2：RandomAccessFile
特点：
1：该对象即可读取，又可写入。
2：该对象中的定义了一个大型的byte数组，通过定义指针来操作这个数组。
3：可以通过该对象的getFilePointer()获取指针的位置，通过seek()方法设置指针的位置。
4：该对象操作的源和目的必须是文件。
5：其实该对象内部封装了字节读取流和字节写入流。
注意：实现随机访问，最好是数据有规律。
代码示例：

class RandomAccessFileDemo {    public static void main(String[] args) throws IOException    {        writeFile_2();        readFile();        System.out.println(Integer.toBinaryString(258));    }    public static void readFile()throws IOException    {        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");        //调整对象中指针。        //raf.seek(8*1);        //跳过指定的字节数        raf.skipBytes(8);        byte[] buf = new byte[4];        raf.read(buf);        String name = new String(buf);        int age = raf.readInt();        System.out.println("name="+name);        System.out.println("age="+age);        raf.close();    }    public static void writeFile_2()throws IOException    {        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");        raf.seek(8*0);        raf.write("周期".getBytes());        raf.writeInt(103);        raf.close();    }    public static void writeFile()throws IOException    {        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");        raf.write("李四".getBytes());        raf.writeInt(97);        raf.write("王五".getBytes());        raf.writeInt(99);        raf.close();    }}

3：管道流
管道读取流和管道写入流可以像管道一样对接上，管道读取流就可以读取管道写入流写入的数据。
注意：需要加入多线程技术，因为单线程，先执行read，会发生死锁，因为read方法是阻塞式的，没有数据的read方法会让线程等待。
代码示例：

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("开始写入数据，等待6秒后。");            Thread.sleep(6000);            out.write("piped lai la".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);        Read r = new Read(in);        Write w = new Write(out);        new Thread(r).start();        new Thread(w).start();    }}

4： ByteArrayInputStream：源：内存
ByteArrayOutputStream：目的：内存。
这两个流对象不涉及底层资源调用，操作的都是内存中数组，所以不需要关闭。
直接操作字节数组就可以了，为什么还要把数组封装到流对象中呢？因为数组本身没有方法，只有一个length属性。为了便于数组的操作，将数组进行封装，对外提供方法操作数组中的元素。
代码示例：

import java.io.*;class ByteArrayStream {    public static void main(String[] args)     {        //数据源。        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());        //数据目的        ByteArrayOutputStream bos = new ByteArrayOutputStream();        int by = 0;        while((by=bis.read())!=-1)        {            bos.write(by);        }        System.out.println(bos.size());        System.out.println(bos.toString());    //  bos.writeTo(new FileOutputStream("a.txt"));    }}

5：转换流
转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。