5）序列化中，子类和父类构造函数的调用问题

对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用

一个类实现了序列化接口，那么其子类都可以进行序列化

4）transient关键字

private void writeObject(java.io.ObjectOutputStream s)
       throws java.io.IOException

private void readObject(java.io.ObjectInputStream s)
       throws java.io.IOException, ClassNotFoundException

分析ArrayList源码中序列化和反序列化的问题

字符流的过滤器

 BufferedReader  --->readLine 一次读一行

 BufferedReader/PrintWriter  --->写一行

FileReader/FileWriter 

直接操作文件，但文本文件无法处理编码格式，需要回归到InputStreamReader/OutputStreamWriter方法

2、字符流

1）编码问题

2）认识文本和文本文件

Java的文本（char）是16位无符号整数，是字符Unicode编码（双字节编码）

文件是byte byte byte.....的数据序列

文本文件是文本（char）序列按照某种编码方案（utf-8，utf-16be，gbk）序列化为byte的存储结果

3）字符流（Reader Write）--->操作的是文本文件

字符的处理，一次处理一个字符

字符的底层任然是基本的字节序列

字符流的基本实现

InputStreamReader 完成byte流解析为char流，按照编码解析

OutputStreamWriter 提供char流到byte客流，按照编码处理

8）BufferedInputStream&BufferedOutputStream

这两个流类位IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

FileOutputStream--->write()方法相当于一滴一滴的把水转移过去

DataOutputStream--->writeXxx()方法方便一些，相当于一瓢一瓢的把水转移过去

BufferedOutputStream--->write()方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入另一个缸中

IO流分为输入流、输出流
还有字节流、字符流
1、字节流：
（1）InputStream：抽象了应用程序读取数据的方式
（2）OutputStream：抽象了应用程序写 出数据的方式
2）EOF = End 读到-1就读到结尾
3）输入流基本方法
int b = in.read();读取一个字节无符号填充到int低八位.-1是EOF
in.read(byte[] buf) 读取数据填充到字节数组buf
in.read(byte[] buf,int start, int size)读取数据到字节数组buf从buf的start位置开始存放size长度分数据
4）输出流基本方法
out.write(int b)写出一个byte到流，b的低8位
out.write(byte[] buf)将buf字节数组都写到流
out.write(byte[] buf, int start,int size) 字节数组buf从start位置开始写size长度的字节到流

5）FileInputStream--->具体实现了在文件上读取数据

6）FileOutputStream--->实现了向文件中写出byte数据的方法

7）DataOutputStream/DataInputStream

对“流”功能得扩展，可以更加方面的读取int，long，字符等类型数据

DataOutputStream

 writeInt()/writeDouble()/writeUT()

IO流分为输入流、输出流
还有字节流、字符流
1、字节流：
（1）InputStream：抽象了应用程序读取数据的方式
（2）OutputStream：抽象了应用程序写 出数据的方式
2）EOF = End 读到-1就读到结尾
3）输入流基本方法
int b = in.read();读取一个字节无符号填充到int低八位.-1是EOF
in.read(byte[] buf) 读取数据填充到字节数组buf
in.read(byte[] buf,int start, int size)读取数据到字节数组buf从buf的start位置开始存放size长度分数据
4）输出流基本方法
out.write(int b)写出一个byte到流，b的低8位
out.write(byte[] buf)将buf字节数组都写到流
out.write(byte[] buf, int start,int size) 字节数组buf从start位置开始写size长度的字节到流

5）FileInputStream--->具体实现了在文件上读取数据

6）FileOutputStream--->实现了向文件中写出byte数据的方法

java.io.File类用于表示文件（目录）

File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问

RandomAccessFile java提供的对文件内容的访问，既可以读文件，也可以写文件。支持随机访问文件，可以访问文件的任意位置。

RandomAccessFile支持随机访问文件，可以访问文件的任意位置

（1）java文件模型
 在硬盘上的文件时 byte byte byte存储的，是数据的集合
（2）打开文件
两种模式：“rw”（读写），“r”（只读）
RandomAccessFile raf = new RandomAccessFile(File,"rw")
文件指针，打开文件时指针在开头 pointer = 0；
（3）写方法：
raf.write(int)--->只写一个字节（后8位），同时指针指向下一个位置，准备再次写入
（4）读方法：
int b = raf.read()--->读一个字节
（5）文件读写完成以后一定要关闭（Oracle官方说明）
raf.close()

package com.imooc.io;

import java.io.File;
import java.io.IOException;

//列出File的一些常用操作，比如过滤、遍历等操作
public class FileUtils {
   /**
    * 列出指定目录下（包括其子目录的）所有文件
    *
    * @param dir
    * @throws IOException
    */
   public static void listDirectory(File dir) throws IOException {
       if (!dir.exists()) {
           throw new IllegalArgumentException("目录：" + dir + "不存在.");
       }
       if (!dir.isDirectory()) {
           throw new IllegalArgumentException(dir + "不是目录！");
       }
//        String[] filenames = dir.list();//返回的是字符串数组 直接子的名称，不包含目录下的内容
//        for (String s : filenames) {
//            System.out.println(dir + "\\" + s);
//        }
       //如果要遍历子目录下的内容就需要构造成File对象的递归操作，File提供了直接返回File对象
       File[] files = dir.listFiles();//返回的是直接子目录（文件）的对象
       if (files != null && files.length > 0) {
           for (File file : files) {
               if (file.isDirectory()) {
                   //递归
                   listDirectory(file);
               } else {
                   System.out.println(file);
               }
           }
       }
   }
}

IO流分为输入流、输出流
还有字节流、字符流
1、字节流：
（1）InputStream：抽象了应用程序读取数据的方式
（2）OutputStream：抽象了应用程序写 出数据的方式
2）EOF = End 读到-1就读到结尾
3）输入流基本方法
int b = in.read();读取一个字节无符号填充到int低八位.-1是EOF
in.read(byte[] buf) 读取数据填充到字节数组buf
in.read(byte[] buf,int start, int size)读取数据到字节数组buf从buf的start位置开始存放size长度分数据
4）输出流基本方法
out.write(int b)写出一个byte到流，b的低8位
out.write(byte[] buf)将buf字节数组都写到流
out.write(byte[] buf, int start,int size) 字节数组buf从start位置开始写size长度的字节到流

andomAccessFile java提供的对文件内容的访问，既可以读文件，也可以写文件。支持随机访问文件，可以访问文件的任意位置。

java文件模型
 在硬盘上的文件时 byte byte byte存储的，是数据的集合
打开文件
两种模式：“rw”（读写），“r”（只读）

RandomAccessFile raf = new RandomAccessFile(File,"rw")
文件指针，打开文件时指针在开头 pointer = 0；

写方法：
raf.write(int)--->只写一个字节（后8位），同时指针指向下一个位置，准备再次写入

读方法：
int b = raf.read()--->读一个字节

文件读写完成以后一定要关闭
raf.close()

import java.io.File;
import java.io.IOException;

// 列出file类的一些常用操作，不如过滤、遍历等操作
public class FileUtils {
public static void listDirectory(File dir) throws IOException{
// exists()方法用于判断文件或目录是否存在
if(!dir.exists()){
throw new IllegalArgumentException("目录：" + dir + "不存在");
}
// isDirectory()方法用于判断File类的对象是否是目录
if(!dir.isDirectory()){
throw new IllegalArgumentException(dir + "不是目录");

}
// list方法用于列出当前目录下的子目录和文件
/*String[] filenames = dir.list(); // 返回的是字符串数组 直接子的名称 不包含子目录下的内容
for (String string : filenames) {
System.out.println(dir + ":\\" + string);
}*/
// 如果要遍历子目录下的内容就需要构造成File对象做递归操作，File提供了返回File对象的API
File[] files = dir.listFiles(); // 返回的是直接子目录（文件）的抽象
//for (File file : files) {
//System.out.println(file);
if(files!=null && files.length > 0){
for (File file : files) {
if(file.isDirectory()){
// 递归
listDirectory(file);
}else{
System.out.println(file);
}
}
}

}



}

java.io.File类在Java中表示文件或目录。
File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问。

创建File对象：File file=new File(String path);
可以通过 alt+/ 查看构造函数
注意：盘符后跟双斜杠 \\ 或者 /
1. file.seperater();获取系统分隔符
2. file.exists();是否存在.存在返回true，不存在返回false
3. file.mkdir();或者file.mkdirs();创建目录或多级目录。
4. file.isDirectory()或者file.isFile()判断是否是目录或者是否是文件。是返回true，不是为false
5. file.delete();删除文件/文件夹。
6. file.createNewFile();创建新文件。
7. file.getName()获取文件名称。
8. file.getAbsolutePath()获取绝对路径。
9. file.getParent();获取父级绝对路径。

这里说"不识别换行符" 我认为readLine就是通过换行符进行断行 读取断行前的内容并赋值.

注意这里的 

String line;

和 !=null

new InputStreamReader 中可以传递字符类型的参数.

new BufferedReader 的参数是 Reader 类型 而这个Reader类型是 抽象类 无法直接new 可以通过 new InputStreamReader 来生成一个子类的对象

把很大的数组直接构造为字符串.

这里他在每次写入后都刷新缓冲区一次.