java-IO流

流的概念

可以理解为数据的流动。就是一个数据流

输入流

输出流

流的概念使得文件、网络、内存等设备可以被统一处理。用来处理设备之间的数据传输

IO流体系

InputStream

字节输入流的抽象类

常用操作 read(): 读入一个字节 read(byte[]): 读入多个字节 close(): 关闭此输入流

示例代码

 InputStream in = new FileInputStream("src\\a.txt");
     
        /**
         *    通过循环将数据放在b中，此处不可写成以下形式，读取两次
         *     while((in.read())!=-1){
         *             System.out.println((char)(in.read()));
         *         }
         */
        byte[] b = new byte[1024];
            int len;
            //将内容每次按字节数组读取并放在数组b中,len为读取数组的长度
           while((len=in.read(b))!=-1){
               System.out.println(len);
               System.out.println(new String(b,0,b.length));
            }

BufferedInputStream 

缓冲流

构造方法

BufferedInputStream(InputStream)  默认8kb

BufferedInputStream(InputStream,int)

InputStream is = new FileInputStream("D:/a.txt");
        InputStream bis = new BufferedInputStream(is);

        // 3、定义一个字节数组转移数据
        byte[] buffer = new byte[4];
        int len; // 记录每次读取的字节数。
        while ((len = bis.read(buffer)) != -1){
            System.out.println(len);
            System.out.println(new String(buffer, 0 , len));
        }

OutputStream

字节输出流的抽象类

常用操作

write(byte[]):向输出流写多个字节

flush(): 清空缓存

close(): 关闭此输出流

常见构造方法

FileOutStream(String filePath)

FileOutStream(String filePath,boolean append)

OutputStream out=new FileOutputStream("d:/3.txt");

OutputStream out=new FileOutputStream("d:/1.txt",true);

示例代码：

 InputStream in = new FileInputStream("D:/a.txt");
        OutputStream out = new FileOutputStream("d:/a1.txt");
        try {
            byte[] buffer = new byte[1024];
            int b;
            // System.out.println(in.read(b));
       //将内容每次按字节数组读取并放在数组b中,返回读取的数组长度
            while ((b = in.read(buffer)) != -1) {
                String inputStr =new String(buffer, 0, b);
                //执行写数据操作
                out.write(inputStr.getBytes());
                out.flush();
            }
        }

BufferedOutputStream

为输出流提供缓冲区

示例代码，执行拷贝

// 1、创建低级的字节输入流与源文件接通
        InputStream is = new FileInputStream("D:/a.txt");
        // a.把原始的字节输入流包装成高级的缓冲字节输入流
        InputStream bis = new BufferedInputStream(is);
        // 2、创建低级的字节输出流与目标文件接通
        OutputStream os = new FileOutputStream("D:/a2.txt");
        // b.把字节输出流管道包装成高级的缓冲字节输出流管道
        OutputStream bos = new BufferedOutputStream(os);
        // 3、定义一个字节数组转移数据
        byte[] buffer = new byte[1024];
        int len; // 记录每次读取的字节数。
        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
            bos.flush();
        }
        bos.close();
        os.close();
        bis.close();
        is.close();

Reader

字符输入流的抽象类

常用操作 read(): 读入一个字符 read(char[]): 读入多个字符 close(): 关闭此输入流

示例代码

  // 1、创建一个文件字符输入流与源文件接通
        Reader fr = new FileReader("src\\a.txt");
        // 2、用循环，每次读取一个字符数组的数据。
        char[] buffer = new char[1024]; // 1K字符
        int len;
        while ((len = fr.read(buffer)) != -1) {
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }

BufferedReader 

为字符输入流增加缓存

构造方法参数为Reader

新增操作 readLine 读入一行，返回String

示例代码

  Reader fr = new FileReader("src\\a.txt");
            // a、把低级的字符输入流包装成高级的缓冲字符输入流。
            BufferedReader br = new BufferedReader(fr);
            char[] ch = new char[1024];
            int len;
            while ((len = br.read(ch)) != -1) {
                String rs = new String(ch, 0, len);
                System.out.print(rs);
            }

 try {
            // 1、创建一个文件字符输入流与源文件接通。
            Reader fr = new FileReader("src\\a.txt");
            // a、把低级的字符输入流包装成高级的缓冲字符输入流。
            BufferedReader br = new BufferedReader(fr);
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

Writer

字符输出流，

常用操作

write(int): 向输出流写一个字符

write(char[]):向输出流写多个字符

write(String): 向输出流写入一个字符串

flush(): 清空缓存

close(): 关闭此输出流

BufferedWriter

示例代码，执行拷贝操作

 // 1、创建一个文件字符输入流与源文件接通。
            Reader fr = new FileReader("src\\a.txt");
            // a、把低级的字符输入流包装成高级的缓冲字符输入流。
            BufferedReader br = new BufferedReader(fr);
            Writer wr = new FileWriter("src\\a1.txt");
            // a、把低级的字符输入流包装成高级的缓冲字符输出流。
            BufferedWriter bw = new BufferedWriter(wr);
            char[] ch = new char[1024];
            int len;
            while ((len = br.read(ch)) != -1) {
                String rs = new String(ch, 0, len);
               wr.write(rs);
               bw.flush();
            }

基本数据类型与对象的输入输出流

基本类型 DataInputStream DataOutputStream，支持类型 8种基本类型 字符串

注意事项 必须配合使用，DataInputStream只能用来读取DataOutputStream写的数据

示例代码

  FileOutputStream out = new FileOutputStream("D:/h.txt");
        //DataOutputStream可以将各种各样的数据转换为二进制
        DataOutputStream dout = new DataOutputStream(out);
        String name = "zhangsan";
        int num = 100;
        float f = 100.8f;
        double d = 10088.00d;
        //表示这个字符串有多长，8个字节的字符串，还有两个字节的前缀，会写入10个字节
        dout.writeUTF(name);
        //4个字节
        dout.writeInt(num);
        //4个字节
        dout.writeFloat(f);
        //8个字节
        dout.writeDouble(d);

        FileInputStream in = new FileInputStream("D:/h.txt");
        DataInputStream din = new DataInputStream(in);
        String readUTF = din.readUTF();
        System.out.println(readUTF);
        int readInt = din.readInt();
        System.out.println(readInt);
        float readFloat = din.readFloat();
        System.out.println(readFloat);
        double readDouble = din.readDouble();
        System.out.println(readDouble);

对象类型 ObjectInputStream ObjectOutputStream
与Serializable接口结合使用，

首先定义个实体类：例如person类，包括姓名和年龄两个字段（用transient关键字标志不进行序列化的状态），实体类实现Serializable接口

示例代码，将对象序列化到文件中

  File file = new File("d:/"+File.separator+"out.txt");
            Person p1 = new Person("jack", 19);
            Person p2 = new Person( "mary", 22);
            List<Person> list = new ArrayList();
            list.add(p1);
            list.add(p2);

            // 创建文件流
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream os = new ObjectOutputStream(fos);
            os.writeObject(list);
            os.close();
            System.out.println("serialization  success");

读取序列化文件

    File file = new File("d:/"+File.separator+"out.txt");
        FileInputStream fis = new FileInputStream(file);
        ObjectInputStream is = new ObjectInputStream(fis);
        List<Person> list = new ArrayList<>();
        try {
            list = (List<Person>)is.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        is.close();
        //遍历list，输出
        for (Person person:list){
            System.out.println(person.toString());
        }

File类

File对象代表磁盘上的文件或目录

常用构造方法

常用方法

 文件工具类的使用

将相关jar包导入项目中进行使用

File f = new File("d:"+File.separator+"demo"+File.separator+"1.txt");
       // File f1 = new File("d://demo");
        //File f = new File("d://demo","1.txt");

Io工具包：
FileUtils.copyFile(new File("D://demo//1.txt"),new File("d://demo1//1.txt"));
FileUtils.deleteDirectory(new File("D://demo"));
FileUtils.copyFile(new File("D://demo//1.txt"),new File("d://demo1//1.txt"));
IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
         new FileOutputStream("D:\\resources\\hushui2.jpeg"));
//       // 2.完成文件复制到某个文件夹下！
FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));
FileUtils.deleteDirectory(new File("D://demo"));