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

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

文件流(FileInputStream 和FileOutputStream)

/*********************************FileInputStream  ********************************************/
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();
/******************************FileOutputStream***********************************************/
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\\1.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)

/*********************************BufferedInputStream**************************************/
        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();
/*********************************BufferedOutputStream**************************************/

        //文件流
        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)

/************************ObjectInputStream 序列化(内存到硬盘)*******************************/
        FileOutputStream fos = new FileOutputStream("d:\\aaa.bin");
        //创建对象流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //这个类需要实现 序列化接口
        Student student1 = new Student("张三",18);
        //实现序列化(写入)
        oos.writeObject(student1);
        //关闭流(包括了flush()方法)
        oos.close();
/********************ObjectOutputStream 反序列化(硬盘到内存)******************************/
        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<Student> 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<Student> studentList = (List<Student>) 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 )

		/***************BufferedReader *********************/
        FileReader fr = new FileReader("d:\\www.txt");
        BufferedReader br = new BufferedReader(fr);
        //读取一行
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }
        /***************BufferedReader *********************/
        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)

        /***************InputStreamReader*********************/
        //字节流
        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);
        }
        /***************OutputStreamWriter*********************/
                FileOutputStream fos = new FileOutputStream("d:\\aaa.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
        //写入
        osw.write("转换流写入");
        osw.close();