IO流与File类

IO流

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

流的分类

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

字节流

字节流的父类（抽象类）：

InputStream（抽象类）:字节输入流
OutputStream（抽象类）:字节输出流

字节流的实现类：FileInputStream的使用

 public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，并指定文件路径
        FileInputStream inputStream = new FileInputStream("d:\\aaa.txt");
        //2读取文件
        //第一种方法读取文件
        int data=0;
        while ((data=inputStream.read())!=-1){
            System.out.println(data);
        }
        //第二种方法读取文件
       byte[] bytes=new byte[100];
       int count=0;
       while((count=inputStream.read(bytes))!=-1){
           System.out.println(new String(bytes,0,count));
       }
        //3.关闭
        inputStream.close();
        System.out.println("执行完毕");
    }

FileOutputStream的使用

 public static void main(String[] args) throws IOException{
        //1创建文件字节输出流
        //如果为false，则直接覆盖该文件上的内容，如果为true，则在文件内容的后面追加添加的字节。
        FileOutputStream outputStream = new FileOutputStream("d:\\bbb.txt",true);
        //2写入文件
        //单个字节的写入
        outputStream.write(97);
        outputStream.write('b');
        outputStream.write('e');
        outputStream.write('q');
       //多个字节的写入
        String s="hello io";
        outputStream.write(s.getBytes());
        //关闭
        outputStream.close();
        System.out.println("执行完毕");
    }

字节流文件的复制：(可以复制图片，以及二进制文件)

public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\\aaa.txt");
        FileOutputStream fo=new FileOutputStream("d:\\ccc.txt");
        byte[] bytes=new byte[1024];
        int count=0;
        while ((count=fi.read(bytes))!=-1){
            fo.write(bytes,0,count);
        }
        fi.close();
        fo.close();
    }

字节缓冲流

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

BufferedInputStream和BufferedOutputStream的使用

 public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\\aaa.txt");
        //创建字节缓冲流,bi作为缓冲区
        BufferedInputStream bi = new BufferedInputStream(fi);
        int data=0;
        while((data=bi.read())!=-1){
            System.out.print((char)data);
        }
        bi.close();
    }
------------------------------------------------------------------
public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("d:\\ccc.txt");
        BufferedOutputStream bo = new BufferedOutputStream(fo);
        for (int i=0;i<10;i++){
            bo.write("hello\r\n".getBytes());
            bo.flush();   //将缓冲区内容刷新到磁盘中
        }
        bo.close();    //直接调用close时，同样将内容刷新到磁盘中了
    }

对象流：ObjectOutputStream/ObjectInputStream

增强了缓冲区功能。
增强了读写8种基本数据类型和字符串功能。
增强了读写对象的功能：
- readObject() :从流中读取一个对象（反序列化）
- writeObject() ：向流中写入一个对象（序列化）

 public static void main(String[] args) throws Exception {
        //1创建对象流
        FileOutputStream fo = new FileOutputStream("d:\\ddd.txt");
        ObjectOutputStream oo = new ObjectOutputStream(fo);
        //写入对象(序列化)
        Student student = new Student("张三",18);
        oo.writeObject(student);
        //3.关闭
        oo.close();
        System.out.println("序列化完成");
    }

 public static void main(String[] args) throws Exception {
        //1创建对象流
        FileInputStream fi = new FileInputStream("d:\\ddd.txt");
        ObjectInputStream oi = new ObjectInputStream(fi);
        //2读取文件（反序列化）
        Student student=(Student)oi.readObject();
        //3关闭
        oi.close();
        System.out.println("反序列化");
        System.out.println(student);
    }

注意点：

序列化的类必须实现Serializable接口。
序列化类中对象属性要求实现Serializable接口。
序列化版本号ID serialVersionUID，保证序列化的类和反序列化的类是同一个类。
使用transient修饰类属性，则这个属性不能被序列化了。
静态属性不能被序列化。
序列化多个对象，可以借助集合实现。

字符流的父类（抽象类）：

Reader:字符输入流（抽象类）
Writer:字符输出流（抽象类）

文件字符流

FileReader
FileWriter

文件字符流的复制（只能复制文本文件,不能复制图片，以及二进制文件）

图片是二进制文件，没有字符编码。不能使用字符流复制。

 public static void main(String[] args) throws Exception {
        //1创建字符流的输入、输出
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        //2复制
        int data=0;
        while((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3关闭
        fr.close();
        fw.close();
    }

字符缓冲流BufferedReader\BufferedWriter

高效读写
支持输入换行符
可一次写一行，读一行

打印流PrintWriter

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

转换流 InputStreamReader\OutputStreamWriter

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

public static void main(String[] args) throws Exception {
        FileInputStream fi = new FileInputStream("d:\\write.txt");
        InputStreamReader is = new InputStreamReader(fi, "utf-8");  //可设置编码方式
        int data=0;
        while((data=is.read())!=-1){
            System.out.print((char)data);
        }
        is.close();
    }
 public static void main(String[] args) throws Exception {
        FileOutputStream fo = new FileOutputStream("d:\\write2.txt");
        OutputStreamWriter ow = new OutputStreamWriter(fo, "utf-8");//可设置编码方式
        for (int i=0;i<10;i++){
            ow.write("好好学习，天天向上\r\n");
            ow.flush();
        }
        ow.close();
    }

File类

概念：代表物理盘符中的一个文件或者文件夹。

调用路径分隔符; File.pathSeparator

调用名称分隔符\ File.separator

 //文件操作
public static void main(String[] args) throws IOException, InterruptedException {
       // separator();
        file();
    }
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    public static void file() throws IOException, InterruptedException {
        //创建文件
        File file = new File("d:\\file.txt");
        //System.out.println(file.toString());
        //判断文件是否存在
        if (!file.exists()){
            boolean newFile = file.createNewFile();
            System.out.println("创建结果为"+newFile);
        }
      //1直接删除
      //  System.out.println("删除结果为"+file.delete());
        //2使用JVM退出的时候删除
     //   file.deleteOnExit();
     //   Thread.sleep(5000);
        //获取文件信息
        System.out.println("获取绝对路径"+file.getAbsolutePath());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取父目录"+file.getParent());
        System.out.println("获取文件长度"+file.length());
        System.out.println("获取文件生成时间"+new Date(file.lastModified()).toLocaleString());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }

//文件夹操作
public static void dir(){
        //创建文件夹
        File dir = new File("d:\\aaa\\bbb");
        if (!dir.exists()){
           // dir.mkdir();  只能生成单级目录
            System.out.println("创建结果"+dir.mkdirs());
        }
        //删除文件夹
        //dir.delete();   （只能删除空目录）
        //dir.deleteOnExit();
        //获取文件信息
        System.out.println("获取绝对路径"+dir.getAbsolutePath());
        System.out.println("获取路径"+dir.getPath());
        System.out.println("获取父目录"+dir.getParent());
        System.out.println("获取文件夹长度"+dir.length());
        System.out.println("获取文件夹生成时间"+new Date(dir.lastModified()).toLocaleString());
        //判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        System.out.println("是否隐藏"+dir.isHidden());
    //获取文件夹中的所有内容
        String[] list = dir.list();
        for (String s : list) {
            System.out.println(s);
        }
    }

FileFilter接口：当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件的才可出现listFiles()的返回值中。

//FileFilter接口的使用，过滤一些文件
        File[] files = dir.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for (File file : files) {
            System.out.println(file);
        }
    }

递归遍历文件夹，递归删除文件夹

public static void main(String[] args) {
       // listDir(new File("d:\\aaa"));
        deletedIR(new File("d:\\aaa"));
    }
    //递归遍历文件夹
    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()){  //如果file是文件夹，则进行递归。
                    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.isDirectory()){
                    deletedIR(file);
                }else{
                    System.out.println(file.getAbsolutePath()+"删除"+file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
    }

posted @ 2020-10-09 00:22 小胖学java 阅读(133) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

小胖学java