Java进阶--I/O流

I/O流

流

流： 内存与存储设备之间传输数据的通道
分类：

• 按流向：
  • 输入流：将存储设备中的内容读入到内存中
  • 输出流：将内存中的内容写入到存储设备中
• 按单位：
  • 字节流：以字节为单位，可以读写所有数据
  • 字符流：以字符为单位，只能读写文本数据

FileInputStream

public class TestFileInputStream {
    public static void main(String[] args) throws Exception {
        java_learning_note a=new java_learning_note();
        //1.创建FileInputStream,并指定文件路径
        FileInputStream file=new FileInputStream(
                "D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        //2.读取文件
        //单字节
        /*int data=0;
        while ((data=file.read())!=-1){
            System.out.println((char)data);
        }*/
        //多字节
        byte[] data=new byte[5];
        int count=0;
        while ((count=file.read(data))!=-1){
            //read读取多个字节，文件中最后剩余字节数没有达到存储数组的容量时
            // 不会覆盖掉上一次存储数组中读取的内容
//            System.out.println(new String(data));
            System.out.println(new String(data,0,count));
            System.out.println(count);
        }

        //3.关闭
        file.close();
        System.out.println("读取结束");
    }

}

FileOutputStream

public class TestFileOutputStream {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流对象
        FileOutputStream fileOutputStream=new FileOutputStream(
                "D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        //2.写入文件
        //单字节
        /*fileOutputStream.write(97);
        fileOutputStream.write('a');
        fileOutputStream.write('c');*/
        //多字节
        String str="hello world!";
        fileOutputStream.write(str.getBytes());
        //3.关闭
        fileOutputStream.close();
        System.out.println("写入完毕！");
    }
}

案例：使用文件字节流实现文件复制

public class Demo {
    public static void main(String[] args) throws Exception {
        //1，创建流
        //1.1，创建文件字节输入流
        FileInputStream fileInputStream=new FileInputStream("D:\\Code_yang\\IDEA_project\\java_learning\\1.jpg");
        //1.1，创建文件字节输出流
        FileOutputStream fileOutputStream=new FileOutputStream("D:\\Code_yang\\IDEA_project\\java_learning\\copy.jpg");
        //2，一边读，一边写
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=fileInputStream.read(buf))!=-1){
            fileOutputStream.write(buf,0,count);
        }
        //3，关闭
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("复制完毕！");
    }
}

字节流

缓冲流

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

BufferedInputStream

public class TestBufferedInputStream {
    public static void main(String[] args) throws Exception {
        //1，创建BufferedInputStream
        FileInputStream fis=new FileInputStream("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2，读取
        /*int data=0;
        while ((data=bis.read())!=-1){
            System.out.print((char)data);
        }*/
        //自己定义缓存区
        byte[] buf=new byte[1024];
        int count=0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3，关闭
        bis.close();
    }
}

BufferedOutputStream

public class TestBufferedOutputStream {
    public static void main(String[] args) throws Exception {
        //1，创建字节缓冲流
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt"));
        //2，写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("hahahaha\r\n".getBytes());//写入缓存区（大小为8K）
            bos.flush();//刷新到硬盘
        }
        //3，关闭
        bos.close();
        System.out.println("写入完成！");
    }
}

对象流

• ObjectOutputStream/ObjectInputStream
• 增强了缓存区功能
• 增强了读写8种基本数据类型和字符串功能
• 增强了读写对象的功能
  • readObject()
  • writeObject()
  • 使用流传输对象的过程称为序列化，反序列化

ObjectInputStream

public class TestObjectInputStream {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis=new FileInputStream("D:\\Code_yang\\IDEA_project\\java_learning\\stu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //2,读取文件（反序列化）
        //反序列化单个对象
//        Student stu=(Student) ois.readObject();

        //反序列化多个对象
        ArrayList<Student> list=(ArrayList<Student>) ois.readObject();
        //3,关闭
        ois.close();
//        System.out.println(stu);
        System.out.println(list);
        System.out.println("反序列化完毕！");
    }
}

ObjectOutputStream

使用ObjectOutputStream实现对象序列化有以下一些要求：

• 类对象想要序列化，类必须实现Serializable接口
• 序列化中的对象属性也要实现Serializable接口
  • 例如，类中的某些属性属于其他类，如，Private Address address;
  • 其中Address类也要实现Serializable接口
• 序列化版本号ID，保证序列化的类和反序列化的类是同一个类
• 使用transient(瞬间的)修饰属性，这个属性不能序列化
• 静态属性不能序列化
• 序列化多个对象可以借助集合实现

Student类

public class Student implements Serializable {
    //serialVersionUID:序列化版本号ID
    private static final long serialVersionUID=100L;
    private String name;
    private transient int age;
    private static String country;

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

    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 +
                '}';
    }
}

序列化

public class TestObjectOutputStream {
    public static void main(String[] args) throws Exception {
        //1，创建对象流
        FileOutputStream fos=new FileOutputStream("D:\\Code_yang\\IDEA_project\\java_learning\\stu.bin");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //2，序列化
        //类对象想要序列化，类必须实现Serializable接口
        //  Serializable是一个标记性接口，标记该类可以进行序列化
        Student stu1=new Student("zhangsan",18,"China");
        //序列化单个对象
//        oos.writeObject(stu1);

        Student stu2=new Student("lisi",20,"China");
        ArrayList<Student> list=new ArrayList<>();
        list.add(stu1);
        list.add(stu2);
        //序列化多个对象可以使用集合
        oos.writeObject(list);
        //3，关闭
        oos.close();
        System.out.println("序列化完毕！");
    }
}

字符流

• 常见字符编码
  • ISO-8859-1：收录除ASCII外，还包括西欧，希腊语，泰语，阿拉伯语，希伯来语对应的文字符号
  • UTF-8：针对Unicode码表的可变长度字符编码，包含所有国家常见的字符
  • GB2312：简体中文
  • GBK：简体中文，扩充
  • BIG5：台湾，繁体中文
  • 编码和解码方式必须相同，不然会出现乱码

FileReader

public class TestFileReader {
    public static void main(String[] args) throws Exception{
        //1，创建FileReader文件字符输入流
        FileReader fr=new FileReader("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        //2，读取文件
        //单字符读取
        /*int data=0;
        while ((data=fr.read())!=-1){
            System.out.print((char) data);
        }*/
        //多字符读取
        int count=0;
        char[] buf=new char[1024];
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3，关闭
        fr.close();
        System.out.println("读取完毕");

    }
}

FileWriter

public class TestFileWriter {
    public static void main(String[] args) throws Exception{
        //1，创建FileWriter对象
        FileWriter fw=new FileWriter("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        //2，写入文件
        for (int i = 0; i < 10; i++) {
            //\r和\n都不能少
            fw.write("java最棒\r\n");
            fw.flush();
        }
        //3，关闭
        fw.close();
        System.out.println("写入完成");
    }
}

案例：使用字符流复制文件

public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1，创建FileReader，FileWriter对象
        FileReader fr=new FileReader("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        FileWriter fw=new FileWriter("D:\\Code_yang\\IDEA_project\\java_learning\\copy.txt");
        //2，读写
        //单字符
        /*int data=0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }*/
        //多字符
        int count=0;
        char[] buf=new char[1024];
        while ((count=fr.read(buf))!=-1){
            fw.write(buf,0,count);
            fw.flush();
        }
        //3，关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流

特点：

• BufferedReader/BufferedWriter
• 高效读写
• 支持输入换行符
• 可以一次写一行，读一行

BufferedReader

public class TestBufferedReader {
    public static void main(String[] args) throws Exception{
        //1，创建缓冲流
        FileReader fr=new FileReader("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        BufferedReader br=new BufferedReader(fr);
        //2，读取
        //多个字符的读取
        int count=0;
        char[] buf=new char[1024];
        while ((count=br.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //一行行的读取
        /*String line="";
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }*/
        //3，关闭
        br.close();
        System.out.println("读取完毕");
    }
}

BufferedWriter

public class TestBufferedWriter {
    public static void main(String[] args) throws Exception{
        //1，创建BufferedWriter对象
        FileWriter fw=new FileWriter("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //2，写入文件
        for (int i = 0; i < 10; i++) {
            bw.write("java天下第一");
            bw.newLine();//写入一个换行符  \r\n    linux  \n
            bw.flush();
        }
        //3，关闭
        bw.close();
        System.out.println("写入完成");
    }
}

打印流 PrintWriter

特点：

• 封装了print()/println()方法，支持写入后换行
• 支持数据原样打印

public class TestPrintWriter {
    public static void main(String[] args) throws Exception{
        //1，创建打印流
        PrintWriter pw=new PrintWriter("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        //2，打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3，关闭
        pw.close();
        System.out.println("打印完毕");
    }
}

转换流

• 桥转换流：InputStreamReader/OutputStreamWriter
• 可将字节流转换为字符流
• 可设置字符的编码方式

InputStreamReader

public class TestInputStreamReader {
    public static void main(String[] args) throws Exception{
        //1，创建InputStreamReader对象
        FileInputStream fis=new FileInputStream("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
        //2，读取文件
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char) data);
        }
        //3，关闭
        isr.close();
    }
}

OutputStreamWriter

public class TestOutputStreamWriter {
    public static void main(String[] args) throws Exception{
        //1，创建OutputStreamWriter对象
        FileOutputStream fis=new FileOutputStream("D:\\Code_yang\\IDEA_project\\java_learning\\text.txt");
        OutputStreamWriter osw=new OutputStreamWriter(fis,"UTF-8");
        //2，写入文件
        for (int i = 0; i < 10; i++) {
            osw.write("java牛皮");
            osw.flush();
        }
        //3，关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

File类

• 代表物理盘符种的一个文件或者文件夹
• 常用方法
  
• FileFilter接口
  • 对文件进行过滤，满足条件的文件才能出现再listFiles()的返回值中

public class TestFile {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOperation();
        directoryOperation();
    }
    //分隔符
    public static void separator(){
        System.out.println("路径分隔符："+ File.pathSeparator);
        System.out.println("名称分隔符："+ File.separator);
    }
    //文件操作
    public static void fileOperation() throws Exception{
        //1，创建文件
        File file=new File("D:\\Code_yang\\IDEA_project\\java_learning\\file.txt");
//        System.out.println(file);
        //如果文件不存在，创建文件
        if(!file.exists()){
            boolean flag=file.createNewFile();
            System.out.println("创建结果："+flag);
        }
        //2，删除文件
        //直接删除
//        System.out.println("删除结果："+file.delete());
        //使用JVM退出时删除
        /*file.deleteOnExit();
        Thread.sleep(3000);*/
        //3，获取文件信息
        System.out.println("获取文件绝对路径："+file.getAbsolutePath());
        System.out.println("获取文件路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取文件父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("获取文件创建时间："+new Date(file.lastModified()));
        //4，判断
        System.out.println("判断文件是否可写："+file.canWrite());
        System.out.println("判断文件是否可读："+file.canRead());
        System.out.println("判断文件是否隐藏："+file.isHidden());
        System.out.println("判断是否是文件："+file.isFile());

    }
    //文件夹操作
    public static void directoryOperation() throws Exception{
        //1，创建文件夹
        File dir=new File("D:\\Code_yang\\IDEA_project\\java_learning\\aaa\\bbb\\ccc");
        if(!dir.exists()){
            //dir.mkdir()只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());//创建多级目录
        }

        //2，删除文件夹
        //直接删除
//        System.out.println("删除结果："+dir.delete());//只能删除空目录
        //使用JVM删除
        /*dir.deleteOnExit();
        Thread.sleep(3000);*/

        //3，获取文件夹信息
        System.out.println("获取文件夹绝对路径："+dir.getAbsolutePath());
        System.out.println("获取文件夹路径："+dir.getPath());
        System.out.println("获取文件夹名称："+dir.getName());
        System.out.println("获取文件夹父目录："+dir.getParent());
        System.out.println("获取文件夹创建时间："+new Date(dir.lastModified()));

        //4，判断
        System.out.println("判断文件夹是否隐藏："+dir.isHidden());
        System.out.println("判断是否是文件夹："+dir.isDirectory());

        //5，遍历文件夹
        File dir2=new File("D:\\Code_yang\\IDEA_project\\java_learning\\aaa");
        String[] list = dir2.list();
        System.out.println("---------遍历文件夹-------");
        for(String string:list){
            System.out.println(string);
        }
        System.out.println("------------FileFilter接口的使用-----------");
        File[] file2=dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });
        for(File file:file2){
            System.out.println(file.getName());
        }
    }
}

案例：递归创建，遍历，删除文件

public class Demo2 {
    public static void main(String[] args) throws Exception{
        createDir(new File("D:\\Code_yang\\IDEA_project\\java_learning\\aaa"));
        listDir(new File("D:\\Code_yang\\IDEA_project\\java_learning\\aaa"));
        delteDir(new File("D:\\Code_yang\\IDEA_project\\java_learning\\aaa"));
    }
    public static void createDir(File dir) throws Exception{
        File[] files=dir.listFiles();
        if(files!=null&&files.length>0){
            for(File file:files){
                if(file.isDirectory()){
                    createDir(file);
                }
            }
        }
        for (int i = 0; i < 2; i++) {
            new File(dir.getAbsolutePath()+"\\"+dir.getName()+String.valueOf(i)+".txt").createNewFile();
            System.out.println(dir.getAbsolutePath()+"\\"+dir.getName()+String.valueOf(i)+".txt===创建成功");
        }
    }

    public static void listDir(File dir){
        System.out.println("---------递归遍历文件夹----------");
        File[] files=dir.listFiles();
        if(files!=null&&files.length>0){
            for(File file:files){
                if(file.isDirectory()){
                    listDir(file);
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }

    public static void delteDir(File dir){
        System.out.println("---------递归删除文件夹----------");
        File[] files=dir.listFiles();
        if(files!=null&&files.length>0){
            for(File file:files){
                if(file.isDirectory()){
                    delteDir(file);
                }else {
                    System.out.println(file.getAbsolutePath()+"删除："+file.delete());
                }
            }
        }
    }
}

Properties：属性集合

• 特点
  • 存储属性名和属性值
  • 属性名和属性值都是字符串类型
  • 没有泛型
  • 和流有关

public class TestProperties {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties=new Properties();
        //添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties);
        //遍历
        Set<String> pronames=properties.stringPropertyNames();
        for(String pro:pronames){
            System.out.println(pro+"===="+properties.getProperty(pro));
        }
        //和流有关的方法
        //list方法--遍历
        PrintWriter pw=new PrintWriter("D:\\Code_yang\\IDEA_project\\java_learning\\print.txt");
        properties.list(pw);
        pw.close();
        //store方法--保存
        FileOutputStream fos=new FileOutputStream("D:\\Code_yang\\IDEA_project\\java_learning\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        //load方法--加载
        Properties p2=new Properties();
        FileInputStream fis=new FileInputStream("D:\\Code_yang\\IDEA_project\\java_learning\\store.properties");
        p2.load(fis);
        fis.close();
        System.out.println(p2);

    }
}

其他相关文章

• Java知识梳理：Java知识梳理
• Java知识梳理–内部类：Java知识梳理–内部类
• Java常用类–Object类：Java常用类–Object类
• Java常用类–包装类：Java常用类–包装类
• Java常用类–String类：java常用类–String类
• Java常用类–时间相关类：Java常用类–时间相关类
• Java常用类–BigDecimal类和System类：Java常用类–BigDecimal类和System类
• Java集合–Collection集合：Java集合–Collection集合
• Java集合–泛型集合：Java集合–泛型集合
• Java集合–Map集合：Java集合–Map集合
• Java进阶–多线程：Java进阶–多线程