25.IO流(2)

字节流：适合复制文件、字符流：适合读取文本文件内容

一、字符流

1.FileReader：文件字符输入流

作用：可以把文件中的数据以字符的形式读入到内存中去

       try (
            //1.创建一个文件字符输入流管道与源文件接通
            Reader fr = new FileReader("io-app2\\src\\cris1.txt");
            ){
            //2.读取文本文件的内容
            //每次读取一个字符
            int c; //记住每次读取的字符编号
            while ((c = fr.read()) != -1){
                System.out.print((char) c);
            }

            //每次读取多个字符
            char[] buffer = new char[3];
            int len;
            while ((len = fr.read(buffer)) != -1){
                System.out.print(new String(buffer, 0, len));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

 2.FileWriter：文件字符输出流

作用：可以把内存中的数据以字符的形式写入到文件中去

       try (
                Writer fw = new FileWriter("io-app2\\src\\cris2.txt");
                ){
            //1.write(int c)：写一个字符出去
            fw.write('a');
            fw.write(97);
            fw.write('高');
            fw.write("\r\n");

            //2.write(String c)：写一个字符串出去
            fw.write("我爱你中国abc");
            fw.write("\r\n");

            //3.write(String c,int pos,int len)：写字符串的一部分出去
            fw.write("我爱你中国",0,3);
            fw.write("\r\n");

            //4.write(char[] buffer)：写一个字符数组出去
            char[] buffer = {'C','罗','和','梅','西'};
            fw.write(buffer);
            fw.write("\r\n");

            //5.write(char[] buffer,int pos,int len)：写字符数组的一部分出去
            fw.write(buffer,0,2);
            fw.write("\r\n");

        } catch (IOException e) {
            e.printStackTrace();
        }

二、缓冲流

1.字节缓冲流

 

       try (
                InputStream is = new FileInputStream("E:\\文件\\ME.jpg");
                //1.定义一个字节缓冲输入流包装原始的字节输入流
                InputStream bis = new BufferedInputStream(is);

                OutputStream os = new FileOutputStream("D:\\ME.jpg");
                //2.定义一个字节缓冲输出流包装原始的字节输出流
                OutputStream bos = new BufferedOutputStream(os);
                
                ){

            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }

 2.字符缓冲流

字符缓冲输入流

       try (
                Reader fr = new FileReader("io-app2\\src\\cris1.txt");
                //创建一个字符缓冲输入流包装原始的字符输入流
                BufferedReader br = new BufferedReader(fr);
                ){

            //按字符读取
            char[] buffer = new char[3];
            int len;
            while ((len = br.read(buffer)) != -1 ){
                System.out.print(new String(buffer, 0, len));
            }

            //按行读取
            String line;//记住每次读取的一行数据
            while ((line = br.readLine()) != null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

 字符缓冲输出流

       try (
                Writer fw = new FileWriter("io-app2\\src\\cris3.txt",true);
                //创建一个字符缓冲输出流管道包装原始的字符输出流
                BufferedWriter bw = new BufferedWriter(fw);
                ){

            bw.write('a');
            bw.write(97);
            bw.write('高');
            bw.newLine();

            bw.write("我爱你中国abc");
            bw.write("\r\n");
        } catch (Exception e) {
            e.printStackTrace();
        }

 三、转换流

1.字符输入转换流

 

       try (
                //1.得到文件原始字节流（GBK形式）
                InputStream is = new FileInputStream("io-app2\\src\\cris4.txt");

                //2.把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is,"GBK");

                //3.把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
                ){

            String line;
            while((line = br.readLine()) != null){
                System.out.println(line);
            }

        } catch (Exception e) {
            e.printStackTrace();

 2.字符输出转换流

       try (
                //1.创建一个文件字节输出流
                OutputStream os = new FileOutputStream("io-app2\\src\\cris6.txt");

                //2.把原始的字节输出流按照指定的字符集编码转换成字符输出流
                Writer w = new OutputStreamWriter(os,"GBK");

                //3.把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(w);
                ){

            bw.write("我爱你中国abc");
            
        } catch (Exception e) {
            e.printStackTrace();
        }

四、打印流

PrintStream与PrintWriter提供的打印方案基本一致，使用哪个都行 

try (

//1.创建一个字节输出流管道
PrintStream ps = new PrintStream("io-app2\\src\\cris5.txt", Charset.forName("GBK"));

//2.创建一个字符输出流管道:高级流管道不支持追加数据，只能包装成低级流管道
PrintWriter pw = new PrintWriter(new FileOutputStream("io-app2\\src\\cris5.txt",true));

     ){
     ps.println(666);
     ps.println("cris");
     ps.println('a');
                   
     pw.write(97);//a
     pw.write("我爱你中国");
            
} catch (Exception e) {
   e.printStackTrace();
}

 

五、数据流

1.数据输出流

       try (
                //1.创建一个数据输出流包装低级的字节输出流
            DataOutputStream dos =
                  new DataOutputStream(new FileOutputStream("io-app2/src/cris7.txt"));
                ){
            dos.writeInt(97);
            dos.writeDouble(100.0);
            dos.writeBoolean(true);
            dos.writeUTF("我爱你中国abc");

        } catch (Exception e) {
            e.printStackTrace();
        }

2.数据输入流 

       try (
            DataInputStream dis =
                new DataInputStream(new FileInputStream("io-app2/src/cris7.txt"));
        ){
            //读写顺序必须和输出顺序一致
            int i = dis.readInt();
            System.out.println(i);

            double d = dis.readDouble();
            System.out.println(d);

            boolean b = dis.readBoolean();
            System.out.println(b);

            String s = dis.readUTF();
            System.out.println(s);

        } catch (Exception e) {
            e.printStackTrace();
        }

 六、序列化流

1.对象字节输出流

        //1.创建一个Java对象
        User u = new User("admin","张三",32,"1234567");

        try (
        //2.创建一个对象字节输出流包装原始的字节输出流
        ObjectOutputStream oos =
            new ObjectOutputStream(new FileOutputStream("io-app2/src/cris8.txt"));
        ){
            oos.writeObject(u);
            System.out.println("序列化对象成功");
        } catch (Exception e) {
            e.printStackTrace();
        }

2.对象字节输入流

       try (
            //1.创建一个对象字节输入流管道，包装低级的字节输入流与源文件接通
            ObjectInputStream ois =
               new ObjectInputStream(new FileInputStream("io-app2\\src\\cris8.txt"));
               ){
            User u = (User) ois.readObject();
            System.out.println(u);
        } catch (Exception e) {
            e.printStackTrace();
        }

七、IO框架

FileUtils.copyFile
(new File("io-app2\\src\\cris1.txt"),new File("io-app2\\src\\cris9.txt"));

FileUtils.copyDirectory(new File("E:\\666"),new File("D:\\666"));

FileUtils.deleteDirectory(new File("D:\\666"));

导包操作