public static void main(String[] args) throws IOException {//1.与文件建立联系 File->数据源File src = new File("D://AAA/test.txt");//2.创建文件字节输入流->管道//InputStream is = new FileInputStream(src);InputStream is = new FileInputStream("D://AAA/test.txt");//3.读取数据int num = -1;  while((num=is.read())!=-1){//4.使用数据System.out.println((char)num);}//5.关闭资源is.close();}

io流主要分为 ：输入流和输出流，

                                字节流、字符流、

                                节点流和功能流（包装流和处理流）

                         输入和输出：基准是程序
                         数据进入程序：就叫输入
                         输出写出程序：就叫输出

1.字节和字符流

  字节输入流(InputStream)：
 *   9          常用方法：
 *                 int read();//读取一个字节的数据，如果没有数据则返回-1
 *                 int read(byte[] b);//将读入的数据存入byte数组，返回读取的长度，如果没有数据则返                      回-1
 *                 void close();//关闭流，释放资源
 * 
 *             常用子类：FileInputStream
 *                     构造方法：
 *                     public FileInputStream(String pathname);
 *                     public FileInputStream(File pathname);

字节输出流(OutputStream)：
 *             常用方法：
 *                 void write(int i);//写出一个字节的数据
 *                 void write(byte[] b);//把byte数组中的数据写出去
 *                 void write(byte[] b,int offset,int len);//把byte数组中从offset位置开始，长度是len的数                        据写出去
 *                 void flush();//刷新，清空缓存区
 *                 void close();//关闭流，释放资源
 * 
 *             常用子类：FileOutputStream
 *                 构造方法：
 *                     //通过构造方法没有传入append，则append默认是覆盖(默认为false)
 *                     public FileOutputStream(String pathname);
 *                     public FileOutputStream(File pathname);
 *                     //append如果为true，则表示追加。如果为false表示覆盖
 *                     public FileOutputStream(String pathname,boolean append);
 *                     public FileOutputStream(File pathname,boolean append);

字符输入流(Reader)：
 *             常用方法：
 *                 int read();//读取一个字符的数据，如果没有数据则返回-1
 *                 int read(char[] ch);//读取数据存入char数组，返回读取的长度，如果没有数据则返回-1
 *                 void close();//关闭流，释放资源
 * 
 *             常用子类：FileReader
 *                 构造方法：
 *                     //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
 *                     //第一次读取的时候会读取8192字节的数据存入byte数组(如果数据量少于8192则有                           多少读多少)
 *                     //把数组对应位置的元素转换成字符进行操作处理。
 *                     //后面每一次读取的时候(调用read方法)，只要byte数组中有数据就不用去磁盘中再                          读取数据
 *                     //直接操作内存中byte数组中的数据就可以了。
 *                     public FileReader(String pathname);    
 *                     public FileReader(File pathname); 

字符输出流(Writer)：
 *             常用方法：
 *                 void write(int i);//写出一个字符的数据
 *                 void write(char[] ch);//写出char数组中的全部数据
 *                 void write(char[] ch,int offset,int len);//写出char数组中，从offset开始到len长的数据
 *                 void write(String str);
 *                 void write(String str,int offset,int len);
 *                 void flush();
 *                 void close();
 * 
 *    常用子类：FileWriter
 *                 构造方法：
 *                     //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
 *                     //写出的字符转换成byte数据存入8192的byte数组中
 *                     //当该byte数组存不下数据的时候，或者 显示的调用flush方法时，
 *                     //会把该byte数组中的数据写出到目标位置
 *                     public FileWriter(String pathname);
 *                     public FileWriter(File pathname);
 *                     public FileWriter(String pathname,boolean append);
 *                     public FileWriter(File pathname,boolean append); 

 2.缓冲流：字节缓冲输入流和字节缓冲输出流作用：较少IO次数，提高IO的效率。

字节输入流(InputStream):
 *         常用和转换流子类：
 *             FileInputStream
 *             BufferedInputStream：
 *                 构造方法：
 *                     //调用下面这个构造方法的时候，底层会创建一个长度是8129的byte数组
 *                     //当第一次读取的时候，会读取数据存入该byte数组中
 *                     //然后从该数组对应位置获取元素，进行操作
 *                     public BufferedInputStream(InputStream is);
 *                     //下面这个构造方法可以自己指定缓冲区大小
 *                     public BufferedInputStream(InputStream is,int size);

字节输出流(OutputStream):
 *         常用子类：
 *             FileOutputStream
 *             BufferedOutputStream：
 *                 构造方法：
 *                     //调用下面这个构造方法的时候，底层会创建一个长度是8192的byte数组
 *                     //当写出数据的时候，会被数据存储在这个8192的byte数组中
 *                     //当该数组存不下数据，或者显示的调用了flush(close)方法，会把缓冲区中的数据                             写出去
 *                     public BufferedOutputStream(OutputStream os);
 *                     //通过下面的构造方法，可以指定缓冲区的大小
 *                     public BufferedOutputStream(OutputStream os,int size);

字符输入流(Reader):
 *         常用子类：
 *             FileReader
 *             BufferedReader：
 *                 构造方法：
 *                     //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
 *                     //调用读取方法，把数据读取存入8192的byte数组
 *                     //把8192byte数组中的数据统一转换成字符存入8192的char数组中
 *                     //从char数组中的对应位置获取元素，进行操作
 *                     public BufferedReader(Reader r);
 *                     public BufferedReader(Reader r,int size);
 * 
 *                 //字符输入流和缓冲字符输入流读取数据，读取的次数是一样的
 *                 //高效体现在字节到字符的转换。

InputStreamReader（字符转换输入流）：
 *                 构造方法：
 *                     //这个构造方法读取数据使用的是默认的字符编码
 *                     public InputStreamReader(InputStream is);
 *                     //这个构造方法读取数据使用的是自己指定的编码
 *                     public InputStreamReader(InputStream is,String charsetName);

字符输出流(Writer):
 *         常用子类：
 *             FileWriter
 *                 调用FileWriter构造方法的时候，底层会创建一个长度是8192的byte数组
 * 
 *             BufferedWriter
 *                 构造方法：
 *                     //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
 *                     //调用写出方法的时候，会把数据写出到8192的char数组中
 *                     //当8192的char数组存不下数据的时候，会同一进行转换(成byte)，
 *                     //存储到8192的byte数组中，然后把8192byte数组中的数据写出去
 *                     public BufferedWriter(Writer w);
 *                     //调用下面这个构造方法可以自己指定缓冲区的大小
 *                     public BufferedWriter(Writer w,int size);
 * 
 *                 //字符缓冲输出流的高效体现在，字符到字节的转换上，写出次数这两种(FileWriter、                     BufferedWriter)是一样的

OutputStreamWriter（字符转换输出流）：
 *                 构造方法：
 *                     //使用默认的字符编码写出数据
 *                     public OutputStreamWriter(OutputStream os);
 *                     //使用自己指定的字符编码写出数据
 *                     public OutputStreamWriter(OutputStream os,String charsetName);

3.对象流 

ObjectInputStream(对象输入流):
      注意事项：
              序列化后，类文件结构不能改变，如果改变了反序列化就会报错。
              如果不能保证不修改类文件结构，则可以在该类中添加一个成员变量(常量)：
                                                      serialVersionUID
              反序列化回来后，会重新构建一个对象
      成员方法：
            final Object readObject();//读取一个对象
      构造方法：
            public ObjectInputStream(InputStream is);
ObjectOutputStream（对象输出流）：
        注意事项：
                a.序列化的对象必须是Serializable类型
                b.成员变量的类型也必须是Serializable类型
                c.使用transient关键字修饰的成员变量不进行序列化
        成员方法：
                void writeObject(Object obj);//将指定的对象写出。
        构造方法：
                public ObjectOutputStream(OutputStream out);

==============================================================
读字节数据：   read(byte[] b) 返回值是int类型

        //3.读取数据int len = 0;  //记录每次读到字节数组中数据的个数byte[] car = new byte[1024];while((len=is.read(car))!=-1){//4.使用数据System.out.println(new String(car,0,len));}

OutputStream : 此抽象类是表示输出字节流的所有类的超类。

FileOutputStream : 文件字节输出流

构建文件字节输出流,参数默认 false,覆盖写入    true 不覆盖 在后面加