4-JAVA入门基础教程视频-（IO框架）

什么是流

概念：内存与存储设备之间传输数据的通道

流的分类

按方向
输入流：将存储设备中的内容读入到内存中
输出流：将内存中的内容写入到存储设备中
按单位
字节流：以字节为单位，可以读写所有数据-例如abc,因为每个字母只占一个字节，所以一个字节一个字节读，就是一个字母一个字母读，但是中文字符只2-3个字节，所以读出来会有3个字节，例如“你”的字节就是228, 189, 160，占用3个字节。如果转成char也转不了对应的中文字符
字符流：以字符为单位，只能读写文本数据
按功能
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

字节流

文件输入

package zz;

import java.io.FileInputStream;

/**
 * FileInputStream的使用
 * 文件字节输入流的使用
 *
 */
public class Demo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        //fis.read()
        //单个字节读取文件，读取文件中的每个字符，返回字节值，例如a=97,b=98,c=99
        //因为文件中是使用UTF-8编码，所以文件中的中文字符占用3个字节，英文字符占用1个字节，但由于java内部用的是Unicode编码，如果代码中有中文字符，占用仅2个字符，不同字符集的中文字符占用字节数不同。
        //int data = 0;//int为4字节，char为2字节
        //while((data = fis.read())!= -1){//当读取到文件末尾时，返回-1
          //  System.out.println((char)data);
        //}
        //一次读取多个字节，如果是英文字符，一个字符就是一个字节，如果是中文字符，一个字符可能由两~三字节组成
        //在不同的编码系统中，一个字符所占用的字节数是不同的。具体来说：
        //ASCII 编码：每个字符占用1个字节。例如，字符“a”在ASCII编码中是97，占用1个字节。
        //UTF-8 编码：每个字符占用的字节数可以从1到4个字节不等。例如，字符“a”在UTF-8编码中也是97，占用1个字节；而字符“你”在UTF-8编码中是228, 189, 160，占用3个字节。
        byte[] buf = new byte[3];//一般用1024字节,一次就读完了
        int count = 0;
        while((count = fis.read(buf))!= -1) {
            System.out.println(new String(buf, 0, count));
        }
        //abc
        //def
        //g
        //关闭文件输入流
        fis.close();
    }
}

补充：
字符集：字符用什么数字表示，例如UTF-8，Unicode
编码：怎么存，存成几个字节
资料补充
为什么采用中文编程不行？

文件输出

package zz;

import java.io.FileOutputStream;

/**
 *演示文件字节输出流的使用
 * FileOutputStream类可以将字节数据写入文件，但是需要指定文件路径。
 */
public class Demo02 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        fos.write(97);
        fos.write("b".getBytes());
       fos.write("c".getBytes());
        fos.close();
        System.out.println("写入成功！");
    }
}

字节流复制文件

package zz;

import java.io.FileInputStream;
import java.io.FileOutputStream;

//使用文件字节流实现文件的复制
public class Demo03 {
    public static void main(String[] args)throws Exception {
        FileInputStream fis = new FileInputStream("C:\\Users\\枫\\Desktop\\服务支持单数据表.png");
        FileOutputStream fos = new FileOutputStream("C:\\Users\\枫\\Desktop\\服务支持单数据表_copy.png");
        //一定读一边写
        byte[] buffer = new byte[1024];
        int count = 0;
        while((count = fis.read(buffer))!= -1){
            fos.write(buffer, 0, count);
        }
        fis.close();
        System.out.println("文件复制成功！");


    }
}

字节缓冲区
提高IO效率，减少访问磁盘的次数
数据存储在缓冲区，flush是将缓冲区的内容写入文件中，也可以直接close

package zz;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓冲流读取
 */
public class Demo04 {
    public static void main(String[] args)throws Exception {
        FileInputStream fis = new FileInputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        // 读取
        int data=0;
        while((data=bis.read())!=-1){
            System.out.print((char)data);
        }
        // 关闭
        bis.close();
    }
}

package zz;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream类可以提供缓冲功能，可以减少磁盘IO操作的次数，提高性能。
 */
public class Demo05 {
    public static void main(String[] args) throws Exception {
        // 创建字节缓冲输出流
        FileOutputStream fos = new FileOutputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        // 写入数据
        for (int i = 0; i < 10; i++) {
            bos.write("Hello World!".getBytes());//写入8k缓冲区
            bos.flush(); //刷新到磁盘
        }
        // 关闭流
        bos.close();
        
    }
}

对象流

序列化

package zz;

import java.io.Serializable;

public class Student implements Serializable {//一定要实现Serializable接口，否则无法序列化
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package zz;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjetcOutputStream进行序列化
*注意事项
 *要求：序列化对象必须实现Serializable接口
 *序列类中对象属性要求实现Serialixable接口
*使用transient（瞬间的）修饰属性，这个属性就不能序列化
*静态属性也不能序列化
*序列化多个对象，可以借助集合实现
 */
public class Demo06 {
    public static void main(String[] args) throws Exception {
        // 创建对象流
        FileOutputStream fos = new FileOutputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        // 序列化对象
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //序列化，将对象写入文件
        Student zhangsan = new Student("张三", 20);
        oos.writeObject(zhangsan);
        // 关闭流
        oos.close();

    }
}

反序列化

package zz;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;

/**
 * 使用ObjectInputStream反序列化对象
 */
public class Demo07 {
    public static void main(String[] args) throws Exception {
        //创建对象流
        FileInputStream fis = new FileInputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //读取文件，反序列化对象
        Student s = (Student) ois.readObject();
        //关闭
        ois.close();
        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

序列化和反序列化注意事项

字符流

字符编码

字符流

文件字符流

package BB;

import java.io.FileReader;

/**
 * 使用FileReader读取文件内容
 */

public class Demo02 {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\枫\\Desktop\\aaa.txt");
        // 读取文件内容
        //单个字符读取
        //int data = 0;
        //while ((data = fr.read())!= -1) {
           // System.out.print((char) data);
       // }
        // 读取文件内容，一次性读取
        char[] buffer = new char[1024];
        int len = 0;
        while ((len = fr.read(buffer))!= -1) {
                    System.out.println(new String(buffer, 0, len));
        }
        // 关闭文件流
        fr.close();
    }
}

package BB;

import java.io.FileWriter;

/**
 * 使用FileWriter类写入文件
 */
public class Demo03 {
    public static void main(String[] args) throws Exception {
        // 创建FileWriter对象
        FileWriter fw = new FileWriter("C:\\Users\\枫\\Desktop\\aaa.txt");
        fw.write("Hello World!");
        // 关闭FileWriter对象
        fw.close();
    }
}

package BB;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReaders和FileWriters复制文件，不能复制图片或二进制文件
 *
 */
public class Demo04 {
    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\枫\\Desktop\\aaa.txt");
        FileWriter fw = new FileWriter("C:\\Users\\枫\\Desktop\\bbb.txt");
        int data = 0;
        while ((data = fr.read())!= -1) {
            fw.write(data);
            fw.flush();
        }
        fr.close();

    }
}

字符缓冲流

package BB;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓冲流读取文件内容
 */
public class Demo05 {
    public static void main(String[] args) throws Exception {
        // 创建字符缓冲流
        FileReader fr = new FileReader("C:\\Users\\枫\\Desktop\\aaa.txt");
        BufferedReader br = new BufferedReader(fr);
        // 读取文件内容
        //第一种方式
        //char[] buf = new char[1024];
        //int count = 0;
        //while ((count = br.read(buf))!= -1) {
           // System.out.print(new String(buf, 0, count));
       // }
        // 第二种方式,一行一行读
        String line=null;
        while ((line = br.readLine())!= null) {
            System.out.println(line);
            }
        
        // 关闭流
        br.close();
    }
}

package BB;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * BufferedWriter的使用
 */
public class Demo06 {
    public static void main(String[] args) throws Exception {
        FileWriter fw = new FileWriter("C:\\Users\\枫\\Desktop\\aaa.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        // 写入数据
        for (int i = 0; i < 10; i++) {
            bw.write("Hello World!");
            bw.newLine();//写入一个换行符\r\n
            bw.flush();
        }
        // 关闭流
        bw.close();
    }
}

打印流
封装了print()和println（）方法，支持写入后换行
支持数据原样打印

package BB;

import java.io.PrintWriter;

/**
 * PrintWriter
 */
public class Demo07 {
    public static void main(String[] args) throws Exception {
        //创建打印流
        PrintWriter pw = new PrintWriter("C:\\Users\\枫\\Desktop\\aaa.txt");
        //打印
        pw.println(97);
        pw.println("hello");
        pw.println(true);
        pw.println(123.456);
        //关闭打印流
        pw.close();
    }
}

转换流
桥转换流
可将字节流转换为字符流
可设置字符的编码方式

package CC;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;

/**
 * InputStreamReader读取文件，指定使用编码
 */
public class Demo01 {
    public static void main(String[] args)  throws Exception {
        FileInputStream fs = new FileInputStream("C:\\Users\\枫\\Desktop\\aaa.txt");
        InputStreamReader isr = new InputStreamReader(fs, "UTF-8");
        int date=0;
        while((date=isr.read())!=-1){
            System.out.print((char)date);
            }
        isr.close();
    }
}

gbk就是ANSI编码

File类

package DD;
import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类的使用
 * 1，分隔符
 * 2，文件操作
 * 3，文件夹操作
 */
public class Demo01 {
        public static void main(String[] args) throws Exception {
            separator();
            fileOperation();
        }
        //分隔符
        public static void separator() {
            System.out.println("路径分隔符"+File.pathSeparator);//windows下为;linux下为:
            System.out.println("名称分隔符"+File.separator);//windows下为\ linux下为/
        }
        //文件操作
        public static void fileOperation() throws IOException, InterruptedException {
            //创建文件
            File file = new File("C:\\Users\\枫\\Desktop\\ddd.txt");
            if(!file.exists()) {
                boolean b = file.createNewFile();
                System.out.println("创建结果" + b);
            }
            //删除文件
           // System.out.println("删除结果" + file.delete());
            //使用JVM退出时删除文件
            //file.deleteOnExit();
            //Thread.sleep(1000);

            //获取文件信息

            System.out.println("绝对路径"+file.getAbsolutePath());
            System.out.println("文件名"+file.getName());
            System.out.println("文件大小"+file.length());
            System.out.println("最后修改时间"+new Date(file.lastModified()));

            //判断
            System.out.println("是否可写"+file.canWrite());
       
        }
}

package DD;
import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类的使用
 * 1，分隔符
 * 2，文件操作
 * 3，文件夹操作
 */
public class Demo01 {
        public static void main(String[] args) throws Exception {
            diretoryOperation();

        }
        //文件夹操作
        public static void diretoryOperation() throws Exception {
            //创建文件夹
            File dir = new File("D:\\aaa\\bbb\\ccc");
            if(dir.exists()){
                System.out.println("文件夹已存在");

            }
            else{
                dir.mkdirs();//创建多级文件夹
                System.out.println("文件夹创建成功");
            }
            //删除文件夹
           // System.out.println("删除文件夹"+dir.delete());//只能删除空目录，而且只是最底层文件夹，不会递归删除
            //使用JVM删除
            //dir.deleteOnExit();
           // Thread.sleep(1000);
            //获取文件夹信息
            System.out.println("获取文件绝对路径："+dir.getAbsolutePath());//D:\aaa\bbb\ccc
            System.out.println("获取文件名："+dir.getName());//ccc
            System.out.println("获取文件父路径："+dir.getParent());//D:\aaa\bbb

            //判断
            System.out.println("是否是文件夹："+dir.isDirectory());//true
            
            //遍历文件夹
            File[] files = dir.listFiles();
            for(File file : files){
                        System.out.println(file.getName());
            }
        }
}

FileFilter接口
只返回满足要求的文件

dir.listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    //过滤文件
                    return pathname.isFile();
                }
            });
            }

递归遍历和递归删除

package DD;

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 */
public class ListDemo {
    public static void main(String[] args) {
        listDir(new File("D:\\aaa\\bbb"));

    }
    public static void listDir(File dir) {
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!= null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    listDir(file);
                } else {
                    System.out.println(file.getName());
                }
            }
        }
        //D:\aaa\bbb
        //D:\aaa\bbb\aaaaa
        //D:\aaa\bbb\ccc
        //hello.txt
        //hrrr.xlsx

    }
    // 递归删除文件夹
    public static void deleteDir(File dir) {
        File[] files = dir.listFiles();
        if (files!= null) {
            for (File file : files) {
                if (file.isDirectory()) {
                            deleteDir(file);
                }
                file.delete();
                }
            }
        dir.delete();
    }
}

Properties
属性集合
特点：
1、存储属性名和属性值
2、属性名和属性值都是字符串类型
3、没有泛型
4、和流有关

package DD;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * 演示Properties集合的使用
 */
public class Demo02  {
    public static void main(String[] args) throws Exception {
        // 创建Properties集合
        Properties properties = new Properties();
        // 向Properties集合中添加键值对
        properties.setProperty("name", "Tom");
        properties.setProperty("age", "25");
        System.out.println(properties.toString());
        //遍历
        //keyset
        //entrySet
        //stringPropertyNames
        Set<String> pronames = properties.stringPropertyNames();
        for (String proname : pronames) {
            System.out.println(proname + "=" + properties.getProperty(proname));
        }
        //和流有关的方法
        //list
        PrintWriter pw = new PrintWriter("C:\\Users\\枫\\Desktop\\aaa.txt");
        properties.list(pw);
        pw.close();

        //保存，store
        FileOutputStream fos = new FileOutputStream("C:\\Users\\枫\\Desktop\\bbb.properties");
        properties.store(fos,"注释");
        fos.close();

        //加载，load
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("C:\\Users\\枫\\Desktop\\bbb.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
    }
}