IO流及File，RandomAccessFile

File类：File类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径，也可以是相对于当前目录而言的相对路径
        File类内部封装的路径可以指向一个文件，也可以指向一个目录，只能操作文件，不能操作文件的内容
        File 类提供了如下三种形式构造方法。
                File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
                File(String path, String name)：path 是路径名，name 是文件名。
                File(File dir, String name)：dir 是路径对象，name 是文件名。
        File类的常用方法
                方法声明           功能描述
                boolean exists()   判断File对象对应的文件或目录是否存在，若存在则返回ture，否则返回false
                boolean delete()   删除File对象对应的文件或目录，若成功删除则返回true，否则返回false
                boolean createNewFile()    当File对象对应的文件不存在时，该方法将新建一个此File对象所指定的新文件，若创建成功则返回true，否则返回false
                String getName()   返回File对象表示的文件或文件夹的名称
                String getPath()   返回File对象对应的路径
                String getAbsolutePath()   返回File对象对应的绝对路径（在Unix/Linux等系统上，如果路径是以正斜线/开始，则这个路径是绝对路径；在Windows等系统上，如果路径是从盘符开始，则这个路径是绝对路径）
                String getParent()     返回File对象对应目录的父目录（即返回的目录不包含最后一级子目录）
                boolean canRead()  判断File对象对应的文件或目录是否可读，若可读则返回true，反之返回false
                boolean canWrite()     判断File对象对应的文件或目录是否可写，若可写则返回true，反之返回false
                boolean isFile()   判断File对象对应的是否是文件（不是目录），若是文件则返回true，反之返回false
                boolean isDirectory()  判断File对象对应的是否是目录（不是文件），若是目录则返回true，反之返回false
                boolean isAbsolute()   判断File对象对应的文件或目录是否是绝对路径
                long lastModified()    返回1970年1月1日0时0分0秒到文件最后修改时间的毫秒值
                long length()  返回文件内容的长度
                String[] list()    列出指定目录的全部内容，只是列出名称
                String[] list(FilenameFilter filter)   接收一个FilenameFilter参数，通过该参数可以只列出符合条件的文件
                File[] listFiles()     返回一个包含了File对象所有子文件和子目录的File数组
        示例：
            File f = new File(path);
            if (f.exists()) // 判断文件是否存在
            {
                f.delete(); // 存在则先删除
            }
            f.createNewFile(); // 再创建

I/O（Input/Output）流，即输入/输出流，是Java中实现输入/输出的基础，它可以方便地实现数据的输入/输出操作。
        按照不同的分类方式，可以分为以下三类：
            1.字节流和字符流
                根据流操作的数据单位的不同，可以分为字节流和字符流。
                字节流以字节为单位进行数据的读写，每次读写一个或多个字节数据；
                字符流以字符为单位进行数据的读写，每次读写一个或者多个字符数据。
            2．输入流和输出流
                根据流传输方向的不同，又可分为输入流和输出流。
                其中输入流只能从流中读取数据，而不能向其写入数据；
                输出流只能向流中写入数据，而不能从中读取数据。
            3．节点流和处理流
                根据流的功能不同，可以分为节点流和处理流。
                其中节点流也被称为低级流，是指可以从一个特定的I/O设备（如磁盘）读写数据的流，它只能直接连接数据源，进行数据的读写操作；
                处理流也被称为高级流，它用于对一个已存在的节点流进行连接和封装，通过封装后的流来实现流的读写能力。当使用处理流时，程序不会直接连接到实际的数据源，而是连接在已存在的流之上。
        字节流：在JDK中，提供了两个抽象类InputStream和OutputStream，它们是字节流的顶级父类，所有的字节输入流都继承自InputStream，所有的字节输出流都继承自OutputStream
            然而一旦遇到IO异常，I/O流的close()方法将无法执行，流对象所占用的系统资源将不能够释放。因此，为了保证I/O流的close()方法一定执行，通常会将关闭流的操作写在finally代码块中
                    finally{
                        try{
                            if(in!=null)              // 如果in不为空,关闭输入流
                                in.close();
                        }catch(Exception e){
                            e.printStackTrace();
                        }
                        try{
                            if(out!=null)             // 如果out不为空,关闭输出流
                                out.close();
                        }catch(Exception e){
                            e.printStackTrace();
                        }
                    }
            InputStream 类的常用子类如下。
                ByteArrayInputStream 类：将字节数组转换为字节输入流，从中读取字节。
                FileInputStream 类：从文件中读取数据。
                FilterInputStream 类
                PipedInputStream 类：连接到一个 PipedOutputStream（管道输出流）。
                SequenceInputStream 类：将多个字节输入流串联成一个字节输入流。
                ObjectInputStream 类：将对象反序列化。

                例：// 创建一个文件字节输入流来读取文件
                      FileInputStream in = new FileInputStream("test.txt");
                      // 定义一个int类型的变量b
                      int b = 0;
                      // 通过循环来读取文件，当返回值为-1结束循环
                      while((b=in.read()) != -1){
                           System.out.println(b);
                       }
                       // 关闭流
                       in.close();



            OutputStream 类的常用子类如下。
                ByteArrayOutputStream 类：向内存缓冲区的字节数组中写数据。
                FileOutputStream 类：向文件中写数据。
                    通过FileOutputStream写数据时，自动创建了文件out.txt，并将自定义的字符串内容写入到了目标文件。
                    如果是通过FileOutputStream向一个已经存在的文件中写入数据，那么该文件中的数据首先会被清空，再写入新的数据。若希望在已存在的文件内容之后追加新内容，则可使用FileOutputStream的构造函数FileOutputStream(String fileName, boolean append)来创建文件输出流对象，并把append 参数的值设置为true。
                FilterOutputStream 类
                PipedOutputStream 类：连接到一个 PipedlntputStream（管道输入流）。
                ObjectOutputStream 类：将对象序列化。

                例：// 创建文件输出流对象，并指定输出文件名称
                   FileOutputStream out = new FileOutputStream("out.txt");
                   // 定义一个字符串
                   String str = "hello";
                   // 将字符串转换为字节数组进行写入操作
                   out.write(str.getBytes());
                   // 关闭流
                   out.close();

            缓冲区读写：// 创建文件输入流对象读取指定目录下的文件
                      FileInputStream in = new FileInputStream("source/src.jpg");
                      // 创建文件输出流对象将读取到的文件内容写入到指定目录的文件中
                      FileOutputStream out = new FileOutputStream("target/dest.jpg");
                      // 定义一个int类型的变量len
                      int len = 0;
                       // 定义一个长度为1024的字节数组作为缓冲区
                       byte[] buff = new byte[1024];
                       // 获取拷贝文件前的系统时间
                       long beginTime = System.currentTimeMillis();
                       // 通过循环将读取到的文件字节信息写入到新文件
                       while ((len = in.read(buff)) != -1) {
                           // 每循环读取一次字节数组，就将所读取到的内容写入到文件
                           out.write(buff,0,len);
                       }
                       // 关闭流
                        in.close();
                        out.close();

            缓冲流类：带缓冲的字节流，分别是BufferedInputStream和BufferedOutputStream，它们的构造方法中分别接收InputStream和OutputStream类型的参数作为对象，在读写数据时提供缓冲功能
                       // 创建用于输入和输出的字节缓冲流对象
                       BufferedInputStream bis = new BufferedInputStream(
                                               new FileInputStream("source/src.jpg"));
                       BufferedOutputStream bos = new BufferedOutputStream(
                                               new FileOutputStream("target/dest.jpg"));
                       // 定义一个int类型的变量len
                       int len = 0;
                       // 通过循环读取输入字节缓冲流中的数据，并通过输出字节缓冲流写入到新文件
                       while ((bis.read()) != -1) {
                            bos.write(len);
                       }
                       // 关闭流
                       bis.close();
                       bos.close();

        字符流：字符流也有两个抽象的顶级父类，分别是Reader和Writer。其中Reader是字符输入流，用于从某个源设备读取字符。Writer是字符输出流，用于向某个目标设备写入字符。
                Reader 类的常用子类如下。
                    CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。
                    StringReader 类：将字符串转换为字符输入流，从中读取字符。
                    BufferedReader 类：为其他字符输入流提供读缓冲区。
                    PipedReader 类：连接到一个 PipedWriter。
                    InputStreamReader 类-子类FileReader类：将字节输入流转换为字符输入流，可以指定字符编码。

                    例：// 创建FileReader对象，并指定需要读取的文件
                       FileReader fileReader = new FileReader("reader.txt");
                       // 定义一个int类型的变量len，其初始化值为0
                       int len = 0;
                       // 通过循环来判断是否读取到了文件末尾
                       while ((len = fileReader.read()) != -1) {
                           // 输出读取到的字符
                           System.out.print((char)len);
                       }
                       // 关闭流
                       fileReader.close();


                Writer 类的常用子类如下。
                    CharArrayWriter 类：向内存缓冲区的字符数组写数据。
                    StringWriter 类：向内存缓冲区的字符串（StringBuffer）写数据。
                    BufferedWriter 类：为其他字符输出流提供写缓冲区。
                    PipedWriter 类：连接到一个 PipedReader。
                    OutputStreamWriter 类-子类FileWriter 类：将字节输出流转换为字符输出流，可以指定字符编码。

                    例：// 创建字符输出流对象，并指定输出文件
                       FileWriter fileWriter = new FileWriter("writer.txt");
                       // 将定义的字符写入文件
                       fileWriter.write("轻轻的我走了，\r\n");
                       // 关闭流
                       fileWriter.close();
转换流：InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符。
       OutputStreamWriter是Writer的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符。

       例：// 1、创建字节输入流对象，获取源文件
        FileInputStream in = new FileInputStream("reader.txt");
        // 将字节输入流对象转换成字符输入流对象
        InputStreamReader isr = new InputStreamReader(in);
        // 创建字符输入缓冲流对象
        BufferedReader br = new BufferedReader(isr);
         // 2、创建字节输出流对象，指定目标文件
         FileOutputStream out = new FileOutputStream("writer.txt");
         // 将字节输出流对象转换成字符输出流对象
         OutputStreamWriter osw = new OutputStreamWriter(out);
         // 创建字符输出缓冲流对象
         BufferedWriter bw = new BufferedWriter(osw);
         // 定义一个字符串变量
         String line = null;
         // 通过循环判断是否读到文件末尾
         while ((line = br.readLine()) != null) {
             // 输出读取到的文件
             bw.write(line);
             bw.newLine();
         }
         // 关闭流
         br.close();
         bw.close();

对象流：ObjectOutputStream：将java对象的基本数据类型和图形写入OutputStream
        ObjectInputStream：对写入的数据反序列化

序列化：对象的序列化（Serializable）是指将一个Java对象转换成一个I/O流中字节序列的过程。
        在Java中，可序列化的类必须实现Serializable或Externalizable两个接口之一。

        对象流和序列化示例：
        public class Dog implements Serializable {
            public String name;

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getSex() {
                return sex;
            }

            public void setSex(String sex) {
                this.sex = sex;
            }

            public int age;
            public String sex;
            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }



            public Dog() {
                super();
            }

            public Dog(String name, int age, String sex) {
                super();
                this.name = name;
                this.age = age;
                this.sex = sex;
            }
        }

        public class ObjectStreane{
            public static void writeObject(){
                Dog dod = new Dog("wangwang",5,"母");
                File file = new File("dog.obj");

                try {
                    OutputStream  out = new FileOutputStream(file);
                    ObjectOutputStream oos = new ObjectOutputStream(out);
                    oos.writeObject(dog);
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }


            }
            public static void main(String[] args) {
                    writeObject();
            }
        }

数据流：DataInputStream
       DataOutputStream

RandomAccessFile可以将文件以指定的操作权限（如只读、可读写等）的方式打开，
                RandomAccessFile的构造方法
                    方法声明   功能描述
                    RandomAccessFile(File file,String mode)    使用参数file指定被访问的文件，并使用mode来指定访问模式
                    RandomAccessFile(String name,String mode)  使用参数name指定被访问文件的路径，并使用mode来指定访问模式

                参数mode有四个值，这四个值的含义如下：
                    ● r：表示以只读的方式打开文件。如果试图对RandomAccessFile对象执行写入操作，会抛出IOException异常，
                    ● rw：表示以“读写”的方式打开文件。如果该文件不存在，则会自动创建该文件。
                    ● rws：表示以“读写”方式打开文件。与“rw”相比，它要求对文件的内容或元数据的每个更新都同步写入到底层的存储设备。
                    ● rwd：表示以“读写”方式打开文件。与“rw”相比，它要求对文件的内容的每个更新都同步写入到底层的存储设备。
                RandomAccesseFile中的常用方法
                        方法声明               功能描述
                        long getFilePointer()  返回当前读写指针所处的位置
                        void seek(long pos)    设定读写指针的位置，与文件开头相隔pos个字节数
                        int skipBytes(int n)   使读写指针从当前位置开始，跳过n个字节
                        void write(byte[] b)   将指定的字节数组写入到这个文件，并从当前文件指针开始
                        void setLength(long newLength)     设置此文件的长度
                        final String readLine()    从指定文件当前指针读取下一行内容
                    示例：   RandomAccessFile r = new RandomAccessFile("test.txt", "r");
                              RandomAccessFile w = new RandomAccessFile("test.txt", "rw");
                              byte[] bytes = new byte[1024];
                              int hasRead = 0;
                              while ((hasRead = raf.read(bytes)) > 0) {
                                 w.write(bytes,0,len);
                              }
                              w.close();
                              r.close();

                RandomAccessFile对象中包含了一个记录指针来标识当前读写处的位置。当程序新建RandomAccessFile对象时，该对象的文件记录指针会在文件开始处（即标识为0的位置），当读写了n个字节后，文件记录指针会向后移动n个字节。