IO流(文件流 , 缓冲流 , 对象流, 字符流 )

IO流(文件流 , 缓冲流 , 对象流, 字符流 )

IO流父类
输入流InputStream : 硬盘–>内存
输出流OutputStream : 内存–>硬盘

文件流(FileInputStream 和FileOutputStream)

1.单个字节读取

        //创建文件输入流,并指定文件路径
        FileInputStream fis =new FileInputStream("D:\aaa.txt");
        //读取文件read(),一个字节一个字节读,返回int 字节值,读完返回-1
        int data = 0;//接字节值的变量
        while ((data = fis.read())!=-1){
            //强转为字符型
            char data1 = (char) data;
            System.out.println(data1);
        }
        //关闭流
        fis.close();


2.字节数组读取
        //创建文件输入流,并指定文件路径
        FileInputStream fis = new FileInputStream("D:\aaa.txt");
        //读取文件read(),一个字节数组一个字节数组的读,返回int 字节值,读完返回-1
        byte[] bytes = new byte[1024];//创建读取的字符数组的缓冲区
        int count = 0;
        while ((count = fis.read(bytes)) != -1){
            System.out.println(new String(bytes,0,count));
        }
        //关闭流
        fis.close();

1.单个字节写入       

        //创建文件输入流,并指定文件路径
        FileOutputStream fos = new FileOutputStream("D:\bbb.txt");
        //写入文件(单字节写入)
        fos.write(97);//这个其实也是a
        fos.write('b');
        fos.write('c');
        //关闭流
        fos.close();


2.字节数组写入
        //创建输出流,并指定文件路径,如果文件存在,文件覆盖
//        FileOutputStream fos = new FileOutputStream("D:\bbb.txt");
        //创建输出流,并指定文件路径,如果文件存在,文件追加
        FileOutputStream fos = new FileOutputStream("D:\bbb.txt",true);
        String s = "abcdefg";
        //获取字符串的字节数组
        byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
        //写入文件(字节数组)
        fos.write(bytes);
        fos.close();


    public static void main(String[] args) throws Exception {
        //创建输入流(目标文件)
        FileInputStream fis = new FileInputStream("D:\desktopIPic.jpeg");
        //创建输出流(复制出来的文件)
        FileOutputStream fos = new FileOutputStream("D:\desktopIPic\fos.jpeg");
        byte[] buf = new byte[1024];//创建缓冲区 1k
        int count = 0;//保存实际读取的字节个数
        //文件复制(边读编写)
        while ((count = fis.read(buf))!=-1){
            //写入文件,防止最后一次读取不是1024b
            fos.write(buf,0,count);
        }
        //关闭流
        fos.close();
    }

缓冲流(BufferedInputStream和BufferedOutputStream)

        FileInputStream fis = new FileInputStream("D:\aaa.txt");
        //创建缓存流
        BufferedInputStream bis = new BufferedInputStream(fis);
        //读取
        int data = 0;
        while ((data = bis.read())!= -1){
            char data1 = (char) data;
            System.out.print(data1);
        }
        //关闭缓存流(内部自动实现关闭文件流)
        bis.close();


        //文件流
        FileOutputStream fos = new FileOutputStream("D:\bbb.txt");
        //创建缓存流
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写入
        for (int i = 0; i < 10; i++) {
            //写入"a0"的字节数组 到8k缓冲区
            bos.write("a0".getBytes(StandardCharsets.UTF_8));
            //文件刷新到硬盘
            bos.flush();
        }
        //关闭缓存流(内部自动实现关闭文件流)
        bos.close();

对象流(ObjectInputStream和ObjectOutputStream)

        FileOutputStream fos = new FileOutputStream("d:\aaa.bin");
        //创建对象流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //这个类需要实现 序列化接口
        Student student1 = new Student("张三",18);
        //实现序列化(写入)
        oos.writeObject(student1);
        //关闭流(包括了flush()方法)
        oos.close();

        FileInputStream fis = new FileInputStream("d:\aaa.bin");
        //创建对象流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //实现反序列化(读取)
        Student stu = (Student) ois.readObject();
        //关闭流(包括了flush()方法)
        ois.close();
        System.out.println(stu);



		
		
        FileOutputStream fos = new FileOutputStream("d:\aaa.bin");
        //创建对象流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        List list = new ArrayList<>();
        //这个类需要实现 序列化接口
        Student student1 = new Student("张三",18);
        Student student2 = new Student("李四",18);
        list.add(student1);
        list.add(student2);
        //实现序列化(写入)
        oos.writeObject(list);
        //关闭流(包括了flush()方法)
        oos.close();
        
		
		FileInputStream fis = new FileInputStream("d:\aaa.bin");
        //创建对象流
        ObjectInputStream ois = new ObjectInputStream(fis);
        //实现反序列化(读取)
        List studentList = (List) ois.readObject();
        //关闭流(包括了flush()方法)
        ois.close();
        System.out.println(studentList);

字符流(FileReader 和FileWriter )

字符流 父类 Reader Writer

        //UTF8编码 一个汉字占3个字节,如果用字节流读取会出现乱码,因为字节流是一个字节一个字节的读取
        FileReader fr = new FileReader("d:\aaa.txt");
        //单个读取 一个字符
        int data = 0;
        while ((data = fr.read())!= -1){
            System.out.print((char) data);
        }
        fr.close();


        //UTF8编码 一个汉字占3个字节,如果用字节流读取会出现乱码,因为字节流是一个字节一个字节的读取
        FileReader fr = new FileReader("d:\aaa.txt");
        //单个读取 一个字符
        char [] buf = new char[1024];
        //实际读取的字符个数
        int count = 0;
        while ((count = fr.read(buf))!= -1){
            System.out.print(new String(buf,0,count));
        }
        fr.close();

        //UTF8编码 一个汉字占3个字节,如果用字节流读取会出现乱码,因为字节流是一个字节一个字节的读取
        FileWriter fw = new FileWriter("d:\www.txt");
        //写入
        for (int i = 0; i < 3; i++) {
            fw.write("字符流写入");
        }
        fw.close();

        FileReader fr = new FileReader("d:\www.txt");
        FileWriter fw = new FileWriter("d:\fw.txt");
        //边读边写复制
        int data = 0;
        while ((data = fr.read())!=-1){
            fw.write(data);
        }
        //关闭
        fw.close();

字符缓存流(BufferedReader 和FileWriter )

		
        FileReader fr = new FileReader("d:\www.txt");
        BufferedReader br = new BufferedReader(fr);
        //读取一行
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }
        
        FileWriter fw = new FileWriter("d:\fw.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //写入
        for (int i = 0; i < 3; i++) {
            bw.write("字符缓冲流");
            //写入一个换行符
            bw.newline();
            bw.flush();
        }
        bw.close();

打印流(PipedWriter)

            PrintWriter pw = new PrintWriter("d:\pw.txt");
            pw.println("打印流");
            pw.close();

转换流(InputStreamReader和OutputStreamWriter)

        
        //字节流
        FileInputStream fis = new FileInputStream("d:\aaa.txt");
        //字节流转换子字符流
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        //读取
        int data = 0;
        while ((data = isr.read())!=-1){
            System.out.println((char)data);
        }
        
                FileOutputStream fos = new FileOutputStream("d:\aaa.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        //写入
        osw.write("转换流写入");
        osw.close();