java笔记整理:IO流

java笔记整理:IO流

IO流

什么是流

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

流的分类

  • 按方向【重点】:
    • 输入流:将<存储设备>中的内容读入到<内存>中
    • 输出流:将<内存>中的内容写入到<存储设备>中
  • 按单位:
    • 字节流:以字节为单位,可以读写所有数据
    • 字符流:以字符为单位,只能读写文本数据
  • 按功能:
    • 节点流:具有实际传输数据的读写功能
    • 过滤流:在字节流的基础之上增强功能

字节流

  • 字节流的父类(抽象类):
    • InputStream:字节输入流
      • public int read(){}
      • public int read(byte[] b){}
      • public int read(byte[] b,int off,int len){}
    • OutputStream:字节输出流
      • public void write(int n){}
      • public void write(byte[] b){}
      • public void write(byte[] b,int off,int len){}

文件字节流

  • FileInputStream
    • public int read(byte[] b) //从流中读取多个字节,将读取到的内容存入b数组,返回实际读到的字节数,如果达到文件的尾部,则返回-1
  • FileOutputStream
    • public void write(byte[] b) //一次写多个字节,将b数组中的所有字节,写入输入流
  • 输入流的使用
package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * FileInputStream的使用
 * 文件字节输入流
 */
public class Demo01 {
    public static void main(String[] args) throws IOException {
        //创建文件字节输入流
        FileInputStream fis = new FileInputStream("E:\\aaa.txt");

        //读取文件
        //单个字节读取
//        int data = 0;
//        while((data=fis.read())!=-1){
//            System.out.print((char) data);
//        }


        //多个字节读取
        byte[] buf = new byte[10];
        int count = 0 ;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        fis.close();
        System.out.println("读取完毕");

        //
    }

}

  • 输出流的使用
package IO;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 输出流的使用
 * FileOutStream
 */
public class Demo02 {
    public static void main(String[] args) throws IOException {
        //创建文件字节输出流对象(true表示添加时不覆盖)
        FileOutputStream fos = new FileOutputStream("E:\\bbb.txt",true);

        //写入文件
//        fos.write(99);
//        fos.write(98);
//        fos.write(97);
        String str = "HelloWorld";
        fos.write(str.getBytes());

        fos.close();
        System.out.println("执行完毕");
    }
}
  • 使用文件流复制
package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 文件流的复制
 */
public class Demo03 {
    public static void main(String[] args) throws IOException {
        //创建输入流
        FileInputStream fis = new FileInputStream("E:\\a.txt");
        //创建输出流
        FileOutputStream fos = new FileOutputStream("E:\\b.txt");

        //一边读,一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

字节缓冲流

  • 缓冲流:BufferedInputStream/BufferedOutputStream
    • 提高IO效率,减少访问磁盘的次数
    • 数据存储在缓冲区中,flush是将缓冲区的内容写入文件中,也可以直接close
    • 使用字节缓冲流读取
package IO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 使用字节缓冲流读取
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws IOException {
        //创建缓冲流BufferedInputStream
        FileInputStream fis = new FileInputStream("E:\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);

        //读取
        int data = 0;
        while ((data=bis.read())!=-1){
            System.out.print((char) data);
        }
        //关闭
        bis.close();
    }
}

  • 使用字节缓冲流写入
package IO;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 * 
 */

public class Demo05 {
    public static void main(String[] args) throws IOException {
        //创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("E:\\b.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写入文件
        for (int i=0;i<10;i++){
            bos.write("HelloWorld\r\n".getBytes());//写入缓冲区
            bos.flush();//刷新到硬盘
        }
        bos.close();//会调用flush()方法
        
    }
}

对象流

  • 对象流:ObjectOutputStream/ObjectInputStream
    • 增强了缓冲区功能
    • 增强了读写8种基本数据类型和字符串功能
    • 增强了读写对象的功能
      • readObject()从流中读取一个对象
      • writeObject(Object obj)向流中写入一个对象
    • 使用流传输对象的过程称为序列化、反序列化
  • 序列化的实现
package IO;

import java.io.*;

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求:
 * 1.序列化的类必须要实现Serializable
 * 2.序列化类中对象属性要求实现Serializable接口
 */
public class Demo06 {
    public static void main(String[] args) throws IOException {
        //创建对象流
        FileOutputStream fis = new FileOutputStream("E:\\a.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fis);

        //序列化(写入操作)
        Student s1 = new Student("张三",18);
        oos.writeObject(s1);

        //关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}
  • 反序列化实现
package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * 使用ObjectInputStream实现反序列化(读取重构成一个对象)
 */
public class Demo07 {
    public static void main(String[] args) throws Exception {
        //创建一个对象流
        FileInputStream fis = new FileInputStream("E:\\a.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取文件(反序列化)
        Student s = (Student) ois.readObject();

        //关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

package IO;

import java.io.Serializable;

/**
 * 学生类
 */
public class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

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

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

字符编码

  • ISO-8859-1收录除ASCLL外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
  • UTF-8:针对Unicode码表的可变长度字符编码
  • GB2312:简体中文
  • GBK:简体中文、扩充
  • BIG5:台湾、繁体中文
  • 注:当编码方式和解码方式不一致时,会出现乱码

字符流

  • 字符流的父类(抽象类)
    • Reader:字符输入流
      • public int read(){}
      • public int read(char[] c){}
      • public int read(char[] b,int off,int len()){}
    • Writer:字符输出流
      • public void write(int n){}
      • public void write(String str){}
      • public void write(char[] c){}

文件字符流

  • FileReader:
    • pubilc int read(char[] c) //从流中读取多个字符,将读到内容存入c数组就,返回实际读到的字符数;如果达到文件的尾部,则返回-1
  • FileWrite:
    • public void write(String str) //一次写多个字符,将b数组中所有字符,写入输出流

字符缓冲流

  • 缓冲流:BufferedReader/BufferedWriter
    • 高效读写
    • 支持输入换行符
    • 可一次写一行、读一行

打印流

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

转换流

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

File类

  • 概念:代表物理磁盘符中的一个文件或文件夹
  • 方法:
    • createNewFile() //创建一个新文件
    • mkdir() //创建一个新目录
    • delete() //删除文件或空目录
    • exists() //判断File对象所代表的对象是否存在
    • getAbsolutePath() //获取文件的绝对路径
    • getName() //取得名字
    • getParent() //获取文件/目录所在的目录
    • isDirectory() //是否是目录
    • isFile() //是否是文件
    • length() //获取文件的长度
    • listFiles() //列出目录中的所有内容
    • renameTo() //修改文件名为
  • 文件操作
package IO;

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

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class Demo08 {
    public static void main(String[] args) throws IOException {
        separator();
        fileOpe();
    }
    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符:"+File.pathSeparatorChar);
        System.out.println("名称分隔符:"+File.separator);
    }
    //(2)文件操作
    public static void fileOpe() throws IOException {
        //1创建文件
        File file = new File("E:\\file.txt");
//        System.out.println(file.toString());
        if(file.exists()) {
            System.out.println("文件已存在");
        }else {
            boolean b = file.createNewFile();
            System.out.println("创建结果为:" + b);

        }
//        //2删除文件
//        //2.1直接删除
//        System.out.println(file.delete());
//
//        //2.2使用JVM退出时删除
//        file.deleteOnExit();

        //3获取文件信息
        //3.1获取文件路径
        System.out.println(file.getAbsoluteFile());
        System.out.println(file.getPath());
        //3.2获取文件名称
        System.out.println(file.getName());
        //3.3获取父目录
        System.out.println(file.getParent());
        //3.4获取文件长度
        System.out.println(file.length());
        //获取文件创建时间
        System.out.println(new Date(file.lastModified()).toLocaleString());

        //判断
        //是否可写
        System.out.println(file.canWrite());
        //是否可读
        System.out.println(file.canRead());
        //是否是文件
        System.out.println(file.isFile());
        //是否隐藏
        System.out.println(file.isHidden());
    }
}

  • 文件夹操作
package IO;

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

/**
 * File类的使用
 * (1)分隔符
 * (2)文件操作
 * (3)文件夹操作
 */
public class Demo08 {
    public static void main(String[] args) throws IOException {
        directoryOpe();
    }
    public static void directoryOpe() throws IOException {
        //创建文件夹
        File dir = new File("E:\\ddd\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if(dir.exists()){
            System.out.println("文件已存在");
        }else{
           // dir.mkdir()创建单级目录
            // dir.mkdirs()创建多级目录
            boolean b = dir.mkdirs();
            System.out.println(b);

        }
        //删除文件夹
        //1.直接删除
        System.out.println(dir.delete());
        //2.调用JVM删除
        dir.deleteOnExit();

        //获取文件夹信息
        //3.1获取文件夹路径
        System.out.println(dir.getAbsoluteFile());
        System.out.println(dir.getPath());
        //3.2获取文件夹名称
        System.out.println(dir.getName());
        //3.3获取父目录
        System.out.println(dir.getParent());
        //获取文件夹创建时间
        System.out.println(new Date(dir.lastModified()).toLocaleString());

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

        //遍历
        File dir2 = new File("C:\\Users\\crush\\Desktop\\一些图片");
        String[] str = dir2.list();
        System.out.println("-------------------");
        for (String string:str
             ) {
            System.out.println(string);
        }
    }
}

FileFilter接口

  • public interface FileFilter

    • boolean accept(File pathname)
  • 当调用File类中的ListFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件才可以出现在listFiles()的返回值中

  • 递归调用和递归删除文件夹

package IO;

import java.io.File;

/**
 * 递归遍历文件夹
 * 递归删除文件夹
 */
public class listDemo {
    public static void main(String[] args) {
        listDir(new File("E:\\aaa\\bbb\\ccc"));
        deleteDir(new File("E:\\aaa") );
    }
    //1.递归调用文件夹
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if(files!=null&&files.length>0){
            for (File file:files
                 ) {
                if(file.isDirectory()){
                    listDir((file));//递归
                }else{
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }

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

    }
}

补充:Properties

  • Properties:属性集合
  • 特点:
    • 存储属性名和属性值
    • 属性名和属性值都是字符串类型
    • 没有泛型
    • 和流有关
  • Properties的使用
package IO;

import java.io.*;
import java.util.Properties;
import java.util.Set;

/**
 * Properties集合的使用
 */
public class Demo09 {
    public static void main(String[] args) throws IOException {
        //创建一个集合
        Properties properties = new Properties();

        //添加元素
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());

        //遍历
        //keySet
        //entrySet
        //stringPropertiesNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro:pronames
             ) {
            System.out.println(pro+":"+properties.getProperty(pro));
        }
        //和流有关的方法
        //4.1 list方法
//        PrintWriter printWriter = new PrintWriter("E:\\ddd\\aaa\\bbb\\print.txt");
//        properties.list(printWriter);
//        printWriter.close();

        //store方法:保存
//        FileOutputStream fos = new FileOutputStream("E:\\\\ddd\\\\aaa\\\\bbb\\\\prin.txt");
//        properties.store(fos, "注释");
//        fos.close();

        //load方法:加载
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("E:\\\\ddd\\\\aaa\\\\bbb\\\\print.txt");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@KaiSa

您的鼓励,将是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值