第三章之IO

2019-01-22

内容：IO流

一、java.io.File类
　　@凡是与输入、输出相关的类、接口都定义在java.io包下面
　　@File是一个类，可以使用构造器构造其实例对象，对象对应着一个文件或者文件夹
 

@Test
    public void Test1() {
        //创建一个File类对象，代表一个文件
        File file1 = new File("d:/io/io.txt");
        //创建一个File类对象，代表一个文件夹
        File file2 = new File("d:/io");
    }

 

　　@相对路径和绝对路径的区别：绝对路径：包括盘符在内的完整的文件路径
         　　　　　　　　　　　　　  相对路径：在当前工程下的文件的路径
　　@File类对象与平台无关
　　@File类中的方法仅涉及对文件的创建、删除、重命名等表面的操作，无法操作文件内容
　　@File的对象作为io流的具体类的构造器的形参
　　注意：mkDir:创建文件夹，只能在上层文件夹存在才能创建成功
   　　　　mkDirs创建文件夹，当上层文件夹不存在时也能创建
   　　　　list()返回一个字符串数组的文件名
  　　　　 listFiles()返回一个文件数组
二、io流
　　@用来处理设备之间的数据传输
　　@JAVA程序中，对数据的输入/输出操作以流的方式进行
　　@java.io包下面提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或者输出数据
　　@流的分类：*按流向分类：输入流和输出流
    　　　　　　   *按数据单位分：字节流和字符流（纯文本文件.txt文件是字符流，其他都是字节流）
    　　　　　　   *按流的角色分：节点流（4个InputStrem,OutputStream,FileReader,FileWriter,都是处理文件的）和处理流
　　@JAVA的io流共涉及40多个类，都是从四个抽象基类派生出来的（InputStrem,OutputStream,Reader,Writer）,并且由这4个基类派生出来的子类的名称都是以其父类的名称作为后缀的

三、FileInputStream
 　

实现读取文件中的内容到程序中并打印出来
 @Test
    public void Test2() {
        //使用FileInputStream流向程序中读文件内容，并打印出来，文件必须存在
        //第二步：创建一个输入流的对象
        FileInputStream fis = null;//写在外面时为了关闭流
        try {
            //第一步：新建一个文件对象
            //File file1 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello.txt");//两种写法都可以
            File file1 = new File("C:/Users/贾博蓉/code/Demo1/src/hello.txt");
            fis = new FileInputStream(file1);
            //第三步：利用流的对象调用方法，实现文件的读取
            int b;
            while ((b = fis.read())!=-1) {
                System.out.print((char)b);
            }
        }catch (Exception e) {
            e.getMessage();
        }finally {
            if (fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
@Test
    public void Test2() {
        //使用FileInputStream流向程序中读文件内容
        //第二步：创建一个输入流的对象
        FileInputStream fis = null;//写在外面时为了关闭流
        try {
            //第一步：新建一个文件对象，将文件传进来
            //File file1 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello.txt");//两种写法都可以
            File file1 = new File("C:/Users/贾博蓉/code/Demo1/src/hello.txt");
            fis = new FileInputStream(file1);
            //第三步：利用流的对象调用方法，实现文件的读取
            byte[] b = new byte[3];
            int len;
            while ((len = fis.read(b))!=-1) {
                for (int i = 0; i < len; i++) {
                    System.out.print((char)b[i]);
                }
            }
        }catch (Exception e) {
            e.getMessage();
        }finally {
            if (fis!=null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

 

四、FileOutputStream

实现将内容写入一个文件中
@Test
    public void Test3() {
        //实现将某些内容写入一个文件中，文件可以不存在
        //第二步：创建一个输出流对象
        FileOutputStream fos = null;
        try {
            //第一步：创建一个文件对象
            File file1 = new File("hello1.txt");
            fos = new FileOutputStream(file1);
            fos.write(new String("hello1").getBytes());
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

 

五、使用FileInputStream和FileOutputStream实现将一个文件内容复制到另一个文件中

@Test
    public void Test4() {
        //实现将一个文件的内容复制到另一个文件中
        //第二步：创建相应的流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //第一步：创建文件对象
            File file1 = new File("C:/Users/贾博蓉/code/Demo1/src/hello.txt");
            File file2 = new File("C:/Users/贾博蓉/code/Demo1/src/hello1.txt");
            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);
            //第三步：调用方法完成复制
            byte[] b = new byte[3];
            int len;
            while((len=fis.read(b))!=-1) {
                fos.write(b, 0, len);
            }
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            if(fis != null) {
                try {
                    fis.close();
                }catch(Exception e) {
                    System.out.println(e.getMessage());
                }
            }
            if(fos != null) {
                try {
                    fos.close();
                }catch(Exception e) {
                    System.out.println(e.getMessage());
                }
            }
        }
    }

 

六、使用FileReader和FileWriter实现将一个文件内容复制到另一个文件中

@Test
    public void Test5() {
        //实现将一个文件的内容复制到另一个文件中
        //第二步：创建相应的流
        FileReader read = null;
        FileWriter write = null;
        try {
            //第一步：创建文件的对象
            File file1 = new File("C:\\Users\\贾博蓉\\code\\JAVA学习笔记\\基础\\第一章\\数组.txt");
            File file2 = new File("C:\\Users\\贾博蓉\\code\\JAVA学习笔记\\基础\\第一章\\数组副本.txt");
            read = new FileReader(file1);
            write = new FileWriter(file2);
            //第三步：调用方法实现复制
            char[] b = new char[10];
            int len;
            while ((len = read.read(b))!=-1) {
                write.write(b, 0, len);
            }
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            if (write!=null) {
                try {
                    write.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
            if (read!=null) {
                try {
                    read.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
        }
    }    

 

七、字符流和字节流复制区别
　　字符流只能复制文本文件，一般用它处理文本文件
　　字节流可以复制文本文件、音频文件等 
八、处理流之缓冲流
　　缓冲流比节点流速度快

@Test
    public void Test6() {
        //使用缓冲流BufferedInputStream和BufferedOutputStream完成文件的复制
        //第二步：创建相应的缓冲流流对象
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //第一步：创建相应的文件对象
            File file1 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello.txt");
            File file2 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello2.txt");
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);
            //第三步：将节点流对象作为形参构造缓存流对象
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //第四步：调用方法完成复制
            byte[] b = new byte[3];
            int len;
            while ((len = bis.read(b))!=-1) {
                bos.write(b, 0, len);
                bos.flush();//相比于节点流新加的
            }
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            if (bos!=null) {
                try {
                    bos.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
        }
        if (bis!=null) {
                try {
                    bis.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
    }
@Test
    public void Test7() {
        //使用缓冲流BufferedReader和BufferedWriter完成文件的复制
        //第二步：创建相应的缓冲流对象
        BufferedReader bread = null;
        BufferedWriter bwrite = null;
        try {
            //第一步：创建文件对象
            File file1 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello.txt");
            File file2 = new File("C:\\Users\\贾博蓉\\code\\Demo1\\src\\hello3.txt");
            FileReader fis = new FileReader(file1);
            FileWriter fos = new FileWriter(file2);
            //第三步：将节点流对象作为缓冲流构造器的形参创建相应的缓冲流
            bread = new BufferedReader(fis);
            bwrite = new BufferedWriter(fos);
            //第四步：调用方法，完成功能
            String str;
            while((str = bread.readLine())!=null) {
                bwrite.write(str);
                bwrite.newLine();
            }
        }catch (Exception e) {
            System.out.println(e.getMessage());
        }finally {
            if (bwrite!=null) {
                try {
                    bwrite.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
        }
        if (bread!=null) {
                try {
                    bread.close();
                }catch (Exception e) {
                    e.getMessage();
                }
            }
    }

 

九、转换流InputStreamReader和OutputStreamWriter
　　功能：*输入时实现字节流到字符流的转换（文件是文本文件），使用InputStreamReader
  　　　　 *输出时实现字符流到字节流的转换，使用OutputStreamWriter

例子：从键盘输入字符串，要求将读取到的整行字符串转成大写输出，然后继续进行输入操作，直到当输入为“e”或者“exit”时退出程序
@Test
    public void Test8() {
        //从键盘输入字符串，要求将读取到的整行字符串转成大写输出，然后继续进行输入操作，直到当输入为“e”或者“exit”时退出程序
        BufferedReader br = null;
        try {
            InputStream is = System.in;//字节流
            InputStreamReader isr = new InputStreamReader(is);//转换为字符流
            br = new BufferedReader(isr);
            while(true) {
                System.out.print("请输入字符串：");
                String str = br.readLine();
                if(str.equals("e")||str.equals("exit")) {
                    System.out.println("退出程序");
                    break;
                }else {
                    System.out.println(str.toUpperCase());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(br!=null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

 

十、打印流PrintStream（字节流）和PrintWriter（字符流）
十一、数据流DateInputStream和DateOutputStream,目的是更方便地操作基本数据类型
十二、对象流ObjectInputStream和ObjectOutputStream,目的是存储和读取对象
　　序列化：用ObjectOutputStream类将一个JAVA对象写入io流
　　反序列化：用ObjectInputStream类从io流中恢复该对象
　　序列化机制：把JAVA对象转换成和平台无关的二进制流，这个二进制流可以放在硬盘中，也可以通过网络传输到另一个网络节点。
　　序列化好处：可以把JAVA对象转换成字节数据来保存和传输
　　可以实现序列化地类要求：*这个类必须实现可序列化接口
      　　　　　　　　　　　　 *这个类中属性地类型必须实现可序列化接口
      　　　　　　　　　　　　 *这个类要提供一个序列号private static final serialVersionUID
    　　　　　　　　　　　　   *使用static和transient修饰地属性不能被序列化
十三、随机存取流RandomAccessFile

@Test
    public void Test9() {
        //用RandomAccessFile实现在一个文件指定位置插入
        RandomAccessFile raf = null;
        try {
            File file = new File("C:\\Users\\贾博蓉\\code\\Demo1\\hello1.txt");
            raf = new RandomAccessFile(file,"rw");
            raf.seek(2);
            byte[] b = new byte[2];
            int len ;
            StringBuffer sb = new StringBuffer();
            while((len = raf.read(b))!=-1) {
                sb.append(new String(b, 0, len));
            }
            raf.seek(2);
            raf.write(new String("xy").getBytes());
            raf.write(sb.toString().getBytes());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            if (raf!=null) {
                try {
                    raf.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }