java学习笔记(7)基本概念之IO

输入流和输出流相对于内存设备而言.

将外设中的数据读取到内存中:输入
将内存的数写入到外设中：输出。


字符流的由来：
其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表。获取对应的文字。
在对这个文字进行操作。简单说：字节流+编码表

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

字节流的两个顶层父类：
1，InputStream  2，OutputStream.

字符流的两个顶层父类：
1，Reader 2，Writer

这些体系的子类都以父类名作为后缀。
而且子类名的前缀就是该对象的功能。





就从熟悉的文字开始字符流，


//需求：将一些文字存储到硬盘一个文件中。
记住；如果要操作文字数据，建议优先考虑字符流。
而且要将数据从内存写到硬盘上，要使用字符流中的输出流。Writer
硬盘的数据基本体现是文件。 希望找到一个可以操作文件的Writer.

字符流缓冲区：
BufferedWriter
    ：newLine();
    
BufferedReader:
    : readLine();


使用缓冲区复制一个文本文件。



装饰设计模式：
    对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。
    

装饰和继承都能实现一样的特点：进行功能的扩展增强。

有什么区别呢？

首先有一个继承体系。
Writer
    |--TextWriter:用于操作文本
    |--MediaWriter：用于操作媒体。
    
想要对操作的动作进行效率的提高。
按照面向对象，可以通过继承对具体的进行功能的扩展。
效率提高需要加入缓冲技术。
    
Writer
    |--TextWriter:用于操作文本
        |--BufferTextWriter:加入了缓冲技术的操作文本的对象。
    |--MediaWriter：用于操作媒体。
        |--BufferMediaWriter:

到这里就哦了。但是这样做好像并不理想。
如果这个体系进行功能扩展，有多了流对象。
那么这个流要提高效率，是不是也要产生子类呢？是。这时就会发现只为提高功能，进行的继承，
导致继承体系越来越臃肿。不够灵活。

重新思考这个问题？
既然加入的都是同一种技术--缓冲。
前一种是让缓冲和具体的对象相结合。
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。

class Buffer{
    Buffer(TextWriter w)
    {}
    
    Buffer(MediaWirter w)
    {
    
    }
}
class BufferWriter extends Writer{
    BufferWriter(Writer w)
    {
    }
}
Writer
    |--TextWriter:用于操作文本
    |--MediaWriter：用于操作媒体。
    |--BufferWriter:用于提高效率。
    
装饰比继承灵活。

特点：装饰类和被装饰类都必须所属同一个接口或者父类。



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

字节流：

InputStream  
    

OutputStream

字节流：
FileInputStream
FileOutputStream
BufferedInputStream
BufferedOutputStream
字符流：
Writer Reader
FileReader
FileWriter
BufferedReader
BufferedWriter


转换流：
InputStreamReader ：字节到字符的桥梁。解码。
OutputStreamWriter：字符到字节的桥梁。编码。

流的操作规律：
之所以要弄清楚这个规律，是因为流对象太多，开发时不知道用哪个对象合适。

想要知道开发时用到哪些对象。只要通过四个明确即可。

1，明确源和目的(汇)
    源：InputStream  Reader
    目的：OutputStream  Writer

2，明确数据是否是纯文本数据。
    源：是纯文本：Reader
        否：InputStream
    目的：是纯文本 Writer
        否：OutputStream
    
    到这里，就可以明确需求中具体要使用哪个体系。
    
3，明确具体的设备。
    源设备：
        硬盘：File
        键盘：System.in
        内存：数组
        网络：Socket流
        
    目的设备：
        硬盘：File
        控制台：System.out
        内存：数组
        网络：Socket流

4，是否需要其他额外功能。
    1，是否需要高效(缓冲区);
        是，就加上buffer.
    2，转换。
    


需求1：复制一个文本文件。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2,是否是纯文本？
        是！
        源：Reader
        目的：Writer
        
    3,明确具体设备。
        源：
            硬盘：File
        目的：
            硬盘：File
    
        FileReader fr = new FileReader("a.txt");
        FileWriter fw = new FileWriter("b.txt");
        
    4,需要额外功能吗？
        需要，需要高效。
        BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
        
================================================

需求2：读取键盘录入信息，并写入到一个文件中。
        
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确设备
        源：
            键盘。System.in
        目的：
            硬盘。File
            
        InputStream in = System.in;
        FileWriter fw = new FileWriter("b.txt");
        这样做可以完成，但是麻烦。将读取的字节数据转成字符串。再由字符流操作。
    4，需要额外功能吗？
        需要。转换。    将字节流转成字符流。因为名确的源是Reader，这样操作文本数据做便捷。
            所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader
        InputStreamReader isr = new InputStreamReader(System.in);
        FileWriter fw = new FileWriter("b.txt");
        
        还需要功能吗？
        需要：想高效。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
        
            
        
===================================================
    
需求3：将一个文本文件数据显示在控制台上。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确具体设备
        源：
            硬盘：File
        目的：
            控制台：System.out
            
        FileReader fr = new FileReader("a.txt");
        OutputStream out = System.out;//PrintStream
    4，需要额外功能吗？
        需要，转换。
        FileReader fr= new FileReader("a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        需要，高效。
        BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
        
================================================================

需求4：读取键盘录入数据，显示在控制台上。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确设备。
        源：
            键盘：System.in
        目的：
            控制台：System.out
        
        InputStream in = System.in;
        OutputStream out = System.out;
        
    4，明确额外功能？
        需要转换，因为都是字节流，但是操作的却是文本数据。
        所以使用字符流操作起来更为便捷。
        InputStreamReader isr = new InputStreamReader(System.in);
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        
        为了将其高效。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
        
        
============================================================

5，将一个中文字符串数据按照指定的编码表写入到一个文本文件中.
    
    1，目的。OutputStream，Writer
    2，是纯文本，Writer。
    3，设备：硬盘File
    FileWriter fw = new FileWriter("a.txt");
    fw.write("你好");
    
    注意：既然需求中已经明确了指定编码表的动作。
    那就不可以使用FileWriter，因为FileWriter内部是使用默认的本地码表。
    只能使用其父类。OutputStreamWriter.
    OutputStreamWriter接收一个字节输出流对象，既然是操作文件，那么该对象应该是FileOutputStream
    
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName);
    
    需要高效吗？
    BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));

什么时候使用转换流呢？

    1，源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁。
        提高对文本操作的便捷。
    2，一旦操作文本涉及到具体的指定编码表时，必须使用转换流 。
    



BufferedReader ，BufferedWriter.高效的体现？
    内部将数组进行封装。
    变成对象后，方便于对缓冲区的操作。提高效率。
    并提供了对文本便捷操作的方法。
    readLine
    newLine。
    
    
    
    
    IO中的其他功能流对象：

1,打印流：
    PrintStream：字节打印流。
        特点：
        1，构造函数接收File对象，字符串路径，字节输出流。意味着打印目的可以有很多。
        2，该对象具备特有的方法 打印方法 print println,可以打印任何类型的数据。
        3，特有的print方法可以保持任意类型数据表现形式的原样性，将数据输出到目的地。
            对于OutputStream父类中的write，是将数据的最低字节写出去。
            
    PrintWriter：字符打印流。
        特点：
        1，当操作的数据是字符时，可以选择PrintWriter，比PrintStream要方便。
        2，它的构造函数可以接收 File对象，字符串路径，字节输出流，字符输出流。
        3，构造函数中，如果参数是输出流，那么可以通过指定另一个参数true完成自动刷新，该true对println方法有效。

什么时候用？
当需要保证数据表现的原样性时，就可以使用打印流的打印方法来完成，这样更为方便。
保证原样性的原理：其实就是将数据变成字符串，在进行写入操作。



SequenceInputStream:
    特点：
    1，将多个字节读取流和并成一个读取流，将多个源合并成一个源，操作起来方便。
    2，需要的枚举接口可以通过Collections.enumeration(collection);
    


ObjectInputStream 和 ObjectOutputStream

对象的序列化和反序列化。

writeObject  readObject

Serializable标记接口

关键字：transient


RandomAccessFile:
    特点：
    1，即可读取，又可以写入。
    2，内部维护了一个大型的byte数组，通过对数组的操作完成读取和写入。
    3，通过getFilePointer方法获取指针的位置，还可以通过seek方法设置指针的位置。
    4，该对象的内容应该封装了字节输入流和字节输出流。
    5，该对象只能操作文件。
    
    通过seek方法操作指针，可以从这个数组中的任意位置上进行读和写
    可以完成对数据的修改。
    但是要注意：数据必须有规律。
    


管道流：需要和多线程技术相结合的流对象。
PipedOutputStream
PipedInputStream




用操作基本数据类型值的对象。
    DataInputStream
    DataOutputStream



设备是内存的流对象。
ByteArrayInputStream ByteArrayOutputStream
CharArrayReader  CharArrayWriter
--------------------

IO流体系：

字符流：
Reader
    |--BufferedReader:
        |--LineNumberReader
    |--CharArrayReader
    |--StringReader
    |--InputStreamReaer
        |--FileReader


Writer
    |--BufferedWriter
    |--CharArrayWriter
    |--StringWriter
    |--OutputStreamWriter
        |--FileWriter
    |--PrintWriter



字节流：
InputStream
    |--FileInputStream:
    |--FilterInputStream
        |--BufferedInputStream
        |--DataInputStream
    |--ByteArrayInputStream
    |--ObjectInputStream
    |--SequenceInputStream
    |--PipedInputStream


OutputStream
    |--FileOutputStream
    |--FilterOutputStream
        |--BufferedOutputStream
        |--DataOutputStream
    |--ByteArrayOutputStream
    |--ObjectOutputStream
    |--PipedOutputStream
    |--PrintStream

RandomAccessFile:

    
转换流的子类和转换流的区别？

InputStreamReader   字节-->字符
    |--FileReader : 字节流+本地默认码表。

OutputStreamWriter  字符-->字节
    |--FileWriter