首页 > 编程语言 > 详细

JavaIO框架

时间：2021-04-10 16:40:18      阅读：18      评论：0      收藏：0      [点我收藏+]

1. 流的概念

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

图示：

技术分享图片

2. 流的分类

按方向（重点）：

输入流：将<存储设备>的内容读入到<内存>中

输出流：将<内存>中的内容写入到<存储设备>中

技术分享图片

按单位：

字节流：以字节为单位，可以读写所有数据

字符流：以字符为单位，只能读写文本数据

按功能：

节点流：具有实际传输数据的读写功能

过滤流：在节点流的基础之上增强功能

3. 字节流

字节流的父类（抽象类）

  • InputStream：字节输入流
  • OutputStream：字节输出流

输入流方法：

技术分享图片

输出流方法：

技术分享图片

文件字节流

FileInputStream：

public int read(byte[] b); 从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1

FileOutputStream：

public void write(byte[] b); 一次写多个字节，将b数组中所有字节，写入输出流

演示FileInputStream：

package com.io.demo01;

import java.io.FileInputStream;

public class Demo01 {

    //演示FileInputStream的使用
    public static void main(String[] args) throws Exception {

        //1. 创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("f:\\aaa.txt");

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

        /*
        //2.2 一次性读取多个字节
        byte[] buf = new byte[4];
        int count = fis.read(buf);
        System.out.println(new String(buf));
        System.out.println(count);

        int count1 = fis.read(buf);
        System.out.println(new String(buf));
        System.out.println(count1);

        int count2 = fis.read(buf);
        System.out.println(new String(buf,0,count2));
        System.out.println(count2);
        */

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

        //3. 关闭
        fis.close();
        System.out.println("执行完毕");

    }
}

字节流复制文件

示例：

package com.io.demo01;

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

public class Demo03 {

    public static void main(String[] args) throws Exception {

        //1. 创建流，实现文件的复制
        //1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("f:\\beautifulGirl.jpg");
        //1.2 文件字节输出流
        FileOutputStream fos = new FileOutputStream("f:\\beautifulGirl2.jpg");

        //2. 一边读，一边写
        byte[] buf = new byte[1024];
        int count = 0;
        while((count = fis.read(buf))!=-1){
            fos.write(buf, 0 , count);
        }

        //3. 关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}

字节缓冲流

BufferedInputStream/BufferedOutputStream

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

示例：

package com.io.demo01;

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

public class Demo04 {

    public static void main(String[] args) throws Exception {

        //1. 创建BufferedInputStream
        FileInputStream fis = new FileInputStream("f:\\aaa.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即可
        bis.close();

    }
}

package com.io.demo01;

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

public class Demo05 {
    public static void main(String[] args) throws Exception {

        //使用字节缓冲流写入文件
        //1. 创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("f:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //2. 写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloWorld\r\n".getBytes()); //写入8K缓冲区
            bos.flush(); //刷新到硬盘，不然没内容
        }

        //3. 关闭
        bos.close();

    }
}

对象流

ObjectInputStream/ObjectOutputStream

  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能
    • readObject() 从流中读取一个对象
    • writeObject() 向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化

序列化类必须要实现Serializable接口

序列化类中对象属性必须要实现Serializable接口

示例：

创建Student类：

package com.io.demo02;

import java.io.Serializable;

public class Student implements Serializable { //序列化标记

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

    public int getAge() {
        return age;
    }

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

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

创建测试类：

package com.io.demo02;

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

public class Demo02 {

    public static void main(String[] args) throws Exception{

        //使用ObjectInputStream实现对象的序列化，读取重构成对象

        //1. 创建对象流
        FileInputStream fis = new FileInputStream("f:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //2. 反序列化（读取操作）
        Student s = (Student) ois.readObject(); //不能读多次

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

    }
}

4. 编码方式

技术分享图片

当编码方式与解码方式不一致时，会出现乱码

5. 字符流

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

  • Reader：字符输入流
  • Writer：字符输出流

字符写入与读取

  • FileReader：从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数，如果达到文件的尾部，则返回-1
  • FileWriter：一次写多个字符，将b数组中所有字符，写入输出流

示例：

package com.io.demo03;

import java.io.FileInputStream;
import java.io.FileReader;

public class Demo01 {
    public static void main(String[] args) throws Exception{

        //创建FileReader对象读取文件
        FileReader fr = new FileReader("f:\\hello.txt");


/*        int data = 0;
        while ((data = fr.read())!=-1){ //读取汉字，三个字节一个字，字节流一个一个读会乱码，要用字符流
            System.out.print((char) data);
        }*/

        //自建缓冲区
        char[] buf = new char[1024];
        int count = 0;
        while ((count = fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        fr.close();

    }
}

package com.io.demo03;

import java.io.FileWriter;

public class Demo02 {
    public static void main(String[] args) throws Exception {

        FileWriter fw = new FileWriter("f:\\write.txt");

        for (int i = 0; i < 10; i++) {
            fw.write("I love you\r\n");
            fw.flush();
        }

        fw.close();
        System.out.println("执行完毕");

    }
}

字符流复制文件

示例：

package com.io.demo03;

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

public class Demo03 {

    //使用FileReader和FileWriter复制文件，注意不能复制图片或二进制文件
    public static void main(String[] args) throws Exception {

        FileWriter fw = new FileWriter("f:\\write01.txt");
        FileReader fr = new FileReader("f:\\write.txt");

        int data = 0;
        while ((data = fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }

        fr.close();
        fw.close();
        System.out.println("执行完毕");

    }
}

字符缓冲流

缓冲流：BuffferedReader/BuffferedWriter

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

示例：

package com.io.demo03;

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

public class Demo04 {

    //使用字符缓冲流读取文件
    public static void main(String[] args) throws Exception {

        //1. 创建对象
        FileReader fr = new FileReader("f:\\write.txt");
        BufferedReader br = new BufferedReader(fr);

        //2.1 第一种方式
        char[] buf = new char[1024];
        int count = 0;
        while ((count = br.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }

        //2.2 第二种方式，一行一行读取
        String line = null;
        while ((line = br.readLine())!=null){
            System.out.println(line);
        }

        br.close();

    }
}

package com.io.demo03;

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

public class Demo05 {

    //使用BufferedWriter
    public static void main(String[] args) throws Exception{

        FileWriter fw = new FileWriter("f:\\write03.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        for (int i = 0; i < 10; i++) {
            bw.write("I love you");
            bw.newLine(); //换行，相当于\r\n
            bw.flush();
        }

        bw.close();
    }
}

打印流

PrintWriter：封装了print()和println()方法，支持写入后换行

支持数据原样打印

示例：

package com.io.demo03;

import javafx.print.Printer;

import java.io.PrintWriter;

public class Demo06 {
    public static void main(String[] args) throws Exception{

        //演示PrintWriter的使用

        //创建对象
        PrintWriter pw = new PrintWriter("f:\\pw.txt");

        //打印
        pw.println(97);
        pw.println(‘a‘);
        pw.println("helloWord");

        pw.close();
        System.out.println("执行完毕");

    }
}

转换流

桥转换流：InputStreamReader/OutputStreamWriter

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

示例：

package com.io.demo03;

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;

public class Demo07 {
    public static void main(String[] args) throws Exception{

        //1. 创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("f:\\write.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();
    }
}

package com.io.demo03;

import javax.xml.ws.WebServiceException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class Demo08 {
    public static void main(String[] args) throws Exception {

        //1. 创建OutputStreamWriter
        FileOutputStream fos = new FileOutputStream("f:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2. 写入
        for (int i = 0; i < 10; i++) {
            osw.write("我爱广东，我爱故乡\r\n");
            osw.flush();
        }

        //3. 关闭
        osw.close();
        System.out.println("执行完毕");

    }
}

6. File类

概念与方法

概念：

代表物理盘符中的一个文件或者文件夹

方法：

createNewFile() //创建物理盘符中的一个文件或者文件夹

mkdir() //创建一个新目录

delete() //删除文件或空目录

exists() //判断File对象所代表的对象是否存在

getAbsolutePath() //获取文件的绝对路径

getName() //取得名字

getParent() //获取文件或目录所在的目录

isDirectory() //是否是目录

isFile() //是否是文件

length() //获得文件的长度

listFiles() //列出目录中的所有内容

renameTo() //修改文件名为

文件操作

示例：

package com.io.demo04;

import com.sun.corba.se.impl.encoding.CDROutputObject;

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

public class Demo01 {

    public static void main(String[] args) throws Exception{

        //File类的使用，分隔符、文件操作、文件夹操作
        separator();

        System.out.println("==============");

        fileOpe();

    }

    public static void separator() {
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separatorChar);
    }

    public static void fileOpe() throws Exception{
        //1. 创建文件
        File file = new File("f:\\newFile.txt"); //不加盘符直接创建在项目文件夹中
        boolean b = file.createNewFile(); //创建文件，没有true，有就false
        System.out.println("创建结果：" + b);
        //2. 删除文件
        //2.1 直接删除
        //System.out.println("删除结果" + file.delete());
        //2.2 使用jvm退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000); //等待5秒钟删除文件
        //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()).toLocaleString());
        //4. 判断
        System.out.println("是否可写：" + file.canWrite()); //文件属性改为只读不能写输出false
        System.out.println("是否是文件：" + file.isFile());
        System.out.println("是否隐藏：" + file.isHidden());
    }
}

文件夹操作

示例：

package com.io.demo04;

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

public class Demo02 {

    public static void main(String[] args) throws Exception{

        directoryOpe();
    }


    public static void directoryOpe() throws Exception{

        //1. 创建文件夹
        File dir = new File("f:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if ((!dir.exists())){
            //dir.mkdir() //创建单级目录
            dir.mkdirs(); //创建多级目录
        }
        //2. 删除文件夹，只删除最底层空目录
        //2.1 直接删除
        //dir.delete();
        //2.2 jvm删除
        //dir.deleteOnExit();
        //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())).toLocaleString());
        //4.判断
        dir.isDirectory();
        dir.isHidden();
        //5. 遍历文件夹（文件夹特殊操作）
        File dir2 = new File("f:\\编程学习笔记");
        String[] files = dir2.list();
        System.out.println("=========================");
        for (String s:
             files) {
            System.out.println(s);
        }

    }
}

FileFilter接口

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

示例（部分代码）：

//6. 文件过滤器接口
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".md")){ //只读取.md文件
                    return true;
                }
                return false;
            }
        });

        for (File s1:
             files2) {
            System.out.println(s1.getName());
        }

递归遍历和递归删除

示例：

package com.io.demo05;

import java.io.File;

public class Demo01 {

    //递归遍历文件夹
    public static void main(String[] args) {
        listDir(new File("f:\\编程学习笔记"));  //自己找一个文件夹遍历
        deleteDir(new File("f:\\编程学习笔记 - 副本")); //删除文件夹
    }

    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();
        System.out.println(dir.getAbsolutePath());
        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()); //删除文件夹
    }

}

7. Properties（集合补充）

属性集合，特点：

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

示例：

package com.io.demo05;

import javafx.print.Printer;

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

/*
演示Properties集合的使用
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties = new Properties();
        //添加数据
        properties.setProperty("username","小明");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //遍历
        //keySet();
        //entrySet();
        //stringPropertyNames();
        for (String pro:
             properties.stringPropertyNames()) {
            System.out.println(pro + "=" + properties.getProperty(pro));
        }

        //和流有关的方法
        //list方法
        /*PrintWriter pw = new PrintWriter("f:\\print.txt");
        properties.list(pw);
        pw.close();*/

        //store方法
        /*FileOutputStream fos = new FileOutputStream("f:\\print1.properties");
        properties.store(fos,"注释");
        fos.close();*/

        //load方法
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("f:\\print1.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }

}

8. 总结

技术分享图片

JavaIO框架

原文：https://www.cnblogs.com/czy2642168812/p/14640176.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！