Java_IO框架详解及其代码

最新推荐文章于 2022-12-26 16:14:21 发布
最新推荐文章于 2022-12-26 16:14:21 发布
阅读量157 收藏
点赞数
分类专栏： java--IO框架 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53331942/article/details/116609565
版权

IO框架的课程目标

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210511181942772.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmN

什么是流

  • 联系内存中的程序与硬盘中的文件
    在这里插入图片描述

流的分类(1)

在这里插入图片描述

流的分类(2)

在这里插入图片描述

字节流的抽象类

在这里插入图片描述

FileInputStream的使用

在这里插入图片描述

  • 第一种：单个字节来读取
		//文件字节输入流
        //1.创建  FileInputStream,并指定路径
        FileInputStream file = new FileInputStream("d:\\aaa.txt");
        //2.读取文件-- file.read()只能读取一个字节,读取到最后一个字节返回-1,返回值类型为字符
        // 所以需要用一个循环来读取所有的字节
        int data=0;
        while ((data=file.read())!=-1){
            //需要将其转换为char类型，在不输出的位该字符的ASCII值
            System.out.print((char) data);
        }
        //3.关闭IO流
        file.close();
        System.out.print("执行完毕");
  • 第二种：一次读取多个字节
		 FileInputStream file =new FileInputStream("d:\\aaa.txt");
         //使用第二种读取方式，所以先创建一个byte类型的数组，返回值就为读取的个数,读取到最后一个就返回-1
         //创建一个字节型数组
         byte[] b = new byte[1024];
         int count = 0;
         while ((count=file.read(b))!=-1) {
            System.out.println(new String(b,0,count));
         }
         file.close();
         System.out.println("读取完毕");
         /*
         abcdefg
         读取完毕
         */

FileOuterStream的使用

		//文件字节输出流
        //1.创建字节输出流对象
        FileOutputStream file = new FileOutputStream("d:\\bbb.txt",true); //此处的true是指：不重复覆盖内容了，继续写入文件
        //2.写入文件--file.write();只能写入一个字节
        String s= "hello,world";
        //如果想将s一次写入文件中，则使用s.getBytes();--获取字符串所对应的字节数组
        file.write(s.getBytes());
//        file.write(97);  //a
//        file.write('b'); //b
//        file.write('d'); //c
        //3.关闭
        file.close();
        System.out.println("执行完毕");

字节流复制文件

		//使用文件字节流来进行复制
        //1.创建流
        //1.1文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\ddd.txt",true); // 此处的true是继续追加
        //2.一边读一边写
        //创建一个字节数组--一般为1k=1024
        byte[] b = new byte[1024];
        //count用于保存实际读取字节个数
        int count = 0;
        while ((count=fis.read(b))!=-1){
            fos.write(b,0,count);
        }
        //3.关闭IO流(2个)
        fis.close();
        fos.close();
        System.out.println("复制完毕");

BufferedInputStream的使用(带缓冲的字节输入流)

在这里插入图片描述

		//使用字节缓冲流读取
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis); // 把fis传给他

        //2.读取
        int data =0;
        //此处使用bis来读取，不用fis了
        while ((data = bis.read())!=-1){
            System.out.print((char)data);
        }

        //3.关闭--关闭缓冲流就可以
        bis.close();

也可以

		//使用字节缓冲流读取
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis); // 把fis传给他

        //2.读取
        int count =0;
        byte[] b = new byte[1024];
        while ((count=bis.read(b))!=-1){
            System.out.println(new String(b,0,count)); //将数组转为字符串输出
        }

        //3.关闭--关闭缓冲流就可以
        bis.close();

BufferedOuputStream的使用

		//使用字节缓冲流写入
        FileOutputStream fos = new FileOutputStream("d:\\eee.txt");
        //将fos传入进去
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //写入文件--用bos
        for (int i = 0; i < 5; i++) {
            //写入字符串，使用getBytes()来获取字节数组
            bos.write("helloworld\r\n".getBytes());//相当于写入一个数组，写入8k的缓冲区
            //使用flush--刷新到硬盘
            bos.flush();
        }
        bos.close();
        System.out.println("完事了");

对象流

在这里插入图片描述

序列化

  • 将类对象写入文件中
public class Student implements Serializable {
    private String name;
    private int age;

		//序列化--写入流--ObjectOutputStream
        //1.首先先创建一个对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        //将fos传入ObjectOutputStream中
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //2.写入文件--序列化
        Student s1 = new Student("张三", 90);
        //将类对象写入文件中
        oos.writeObject(s1);

        //3.关闭--oos
        oos.close();
        System.out.println("序列化完毕");

需注意：序列化一个类， 该类必须实现Serializable接口，而且该类中的 对象属性 也必须实现Serializable接口！！！

反序列化

  • 读取文件中的对象
		//序列化--输出流--ObjectInputStream
        //1.首先先创建一个对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        
        
        //读取对象文件--readObject()
        Object o = ois.readObject();
        //Object o = ois.readObject();  会报错---不能读取多次
        
        ois.close();
        System.out.println("反序列化完毕");
        System.out.println(o.toString()); //  Student{name='张三', age=90}

序列化与反序列化的注意事项

  • 注意以下事项
    在这里插入图片描述

常见的字符编码

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210512152919892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzMzMTk0Mg==,size_16,color_FFFFFF,t_70）

字符流抽象类

在这里插入图片描述

FileReader的使用

  • 读取字符在这里插入图片描述
//1.创建一个文件字符输入流
        // 因为文件中有中文，如果使用字节流读取的话出现乱码（UTF-8中一个汉字3个字节），所以需要使用字符流来读取
        FileReader re = new FileReader("d:\\aaa.txt");

        //2.1
        int data = 0;
        while ((data = re.read()) != -1) {
            System.out.print((char) data);
			}

        //2.2
        int count = 0;
        char[] c = new char[1024];
        while ((count = re.read(c)) != -1) {
                System.out.println(new String(c, 0, count));
             } 
		//3.关闭
        re.close();

FileWriter使用

  • 输出字符

在这里插入图片描述

//创建一个FileWriter
        FileWriter fw =new FileWriter("d:\\aaa.txt",true);
        fw.write("\r\n你好啊程诗雯");
        fw.close();

//创建一个FileWriter
        FileWriter fw =new FileWriter("d:\\aaa.txt",true);
        for (int i = 0; i < 10; i++) {
            fw.write("\r\n你好啊程诗雯");
            //使用flush进行刷新--存入硬盘中
            fw.flush();
        }

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

字符流复制文件

注意：使用FileReader和FileWriter只能复制文本文件，不能复制图片，声音，等二进制文件

注意：使用字节流可以复制任意文件

		//使用FileReader和FileWriter只能复制文本文件，不能复制图片，声音，等二进制文件
        FileReader re = new FileReader("d:\\aaa.txt");
        FileWriter fw = new FileWriter("d:\\bbb.txt",true);
        int count=0;
        char[] c=new char[1024];
        while((count=re.read(c))!=-1){
            fw.write(c,0,count);
            fw.flush();
        }
        re.close();
        fw.close();
        System.out.println("复制成功");

BufferedReader的使用

  • 新增加一个新的读取方法----readLine() 一行一行的读取，如果读取完事返回Null
		// 使用字符缓冲流读取文件
        FileReader re = new FileReader("d:\\aaa.txt");
        BufferedReader br =new BufferedReader(re);
        //1.1
        int data = 0;
        char[] c= new char[1024];
        while((data=br.read(c))!=-1){
            System.out.print(new String(c,0,data));
        }
        
        
        //1.2 一行一行的读取---readLine()
        String s= null;
        while((s=br.readLine())!=null){
            System.out.println(s);
        }

        br.close();
        System.out.println("使用字符缓冲流读取文件");

BufferedWriter

  • 新增加一个换行方法—newLine（）；
// 使用字符缓冲流输出文件
        FileWriter fw = new FileWriter("d:\\man.bin");
        BufferedWriter bw = new BufferedWriter(fw);
        for (int i = 0; i < 10; i++) {
            bw.write("你真厉害");
            //使用newLine()方法进行换行
            bw.newLine();
            //刷新
            bw.flush();
        }
        bw.close();
        System.out.println("使用字符缓冲流输出文件");

PrintWriter（打印流）的使用

在这里插入图片描述

  • 支持数据原样打印
		//1.创建打印流
        PrintWriter pw =new PrintWriter("d:\\asf.txt");
        //2.打印--print（）
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        pw.close();
        System.out.println("完事");

转换流

在这里插入图片描述

转换流的使用

//使用InputStreamReader读取文件，指定使用的编码
        //1.创建转换流
        //首先创建字节流---将字节流装换为字符流
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //转换流可以指定编码方式
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        int data=0;
        while((data = isr.read())!=-1){
            System.out.print((char)data);
        }
        isr.close();
        System.out.println("完成");

		//使用OutputStreamReader写入文件，指定使用的编码
        //1.创建转换流
        //首先创建字节流---将字节流装换为字符流
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        //转换流可以指定编码方式
        OutputStreamWriter otw = new OutputStreamWriter(fos,"gbk");
        for (int i = 0; i < 10; i++) {
            otw.write("我爱北京，我爱故乡\r\n");
            otw.flush();
        }
        otw.close();
        System.out.println("完成");

File 类

在这里插入图片描述

文件的操作

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


    //(2)文件操作
    public static void fileOpen() throws IOException, InterruptedException {
        //1.创建文件
        File file = new File("d:\\file.txt"); //只是创建了一个文件对象，文件还没有生成   如果不指定哪盘则在当前项目下创建
        //使用creatNewFile()  创建文件
        if (!file.exists()){//  取反判断
            file.createNewFile();
            System.out.println("创建成功");
        }

        // 2.1删除文件---delete（）
        file.delete();
        System.out.println("删除成功");

        //2.2删除文件---使用jvm退出时删除  deleteOnExit();
        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()); //输出字节数,一个汉字3个字节
        System.out.println("获取文件的创建时间"+new Date(file.lastModified()).toLocaleString()); //获取文件的创建时间2021-5-12 19:29:47
                


        //4.判断
        System.out.println("是否可写："+file.canWrite());//是否可写：true
        System.out.println("是否是文件："+file.isFile());//是否是文件：true
        System.out.println("是否是隐藏的："+file.isHidden());//是否是隐藏的：false

文件夹的操作

	//(3)文件夹的操作
    public static void directoryOpe() throws InterruptedException {
        //1.创建文件夹  (1)先创建一个dir对象（2）在使用mkdir()进行创建
        File dir =new File("d:\\file\\bbb\\ccc");
        if (!dir.exists()){
            //mkdir()只能创建单级目录   mkdirs()创建多级目录
            dir.mkdirs();
        }

        //2.1删除文件夹
        dir.delete(); //注意：只可以删除最里层的目录而且必须为空的！！！
        //2.1删除文件夹---jvm进行删除
        dir.deleteOnExit();  //也是只能删除最里层的目录
        Thread.sleep(5000);

        //3.获取文件夹信息
        System.out.println("获取文件绝对路径："+dir.getAbsolutePath());  //获取文件绝对路径：d:\file\bbb\ccc
        System.out.println("获取路径："+dir.getPath()); //获取路径：d:\file\bbb\ccc
        System.out.println("获取文件夹名称："+dir.getName());  //最里层的文件夹名称  获取文件夹名称：ccc
        System.out.println("获取文件夹的父目录："+dir.getParent());  //获取文件夹的父目录：d:\file\bbb
        System.out.println("获取文件夹的创建时间："+new Date(dir.lastModified()).toLocaleString());  //获取文件夹的创建时间：2021-5-12 19:59:20


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

        //5.遍历文件夹--list()  返回值为字符串数组
        File dir2 = new File("D:\\code");
        String[] list = dir2.list();
        for (String s : list) {
            System.out.println(s);
        }

FileFilter 接口

在这里插入图片描述

  • 使用了匿名内部类
    在这里插入图片描述

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

  • 递归遍历文件夹（包括子文件夹中的文件）
public static void main(String[] args) throws Exception {
        test(new File("D:\\code"));

    }
    public static void test (File dir) {
    	//遍历一个文件夹
        File[] files = dir.listFiles();
         //打印该文件夹的路径
        System.out.println(dir.getAbsoluteFile());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    test(file);
                }else{
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
  • 递归删除文件夹
public class practice {
    public static void main(String[] args) {
        test(new File("D:\\新建文件夹"));
    }
    public static void  test(File dir){
        File[] files = dir.listFiles();
        if (files.length>0&&files!=null){
            for (File file : files) {
                if (file.isDirectory()){
                    test(file);
                }else{
                    file.delete();
                }
            }
        }
        //上面是删除文件  下面是删除文件夹
        dir.delete();
        System.out.println("删除成功");
    }
}

Properties

在这里插入图片描述

Properties的使用

        //1.创建一集合
        Properties properties = new Properties();
        //2.添加数据
        properties.setProperty("Usename","lihoa");
        properties.setProperty("age", "20");
        System.out.println(properties);
        //3.遍历
        //3.1----keySet
        //3.1----entrySet
        //3.1----StringPropertyName()
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+"========="+properties.getProperty(string));
        }

        //4.和流有关的方法
        //---------list方法----------
        PrintWriter p =new PrintWriter("d:\\aaa.txt");
        properties.list(p);
        p.close();

        //-----------store保存----------
        FileOutputStream fos =new FileOutputStream("d:\\print.properties");//属性集合的扩展名是properties
        //properties文件一般不含有中文
        //第二个参数是注释
        properties.store(fos,"注释");
        fos.close();

        //-------load方法加载---------
        Properties p1 = new Properties();
        FileInputStream fis = new FileInputStream("D:\\print.properties");
        p1.load(fis);
        fis.close();
        System.out.println(p1.toString());

总结

在这里插入图片描述

@小半
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】Java中的IO（输入/输出）框架入门介绍
本本本添哥
08-06 211
Java中的IO（输入/输出）框架是一个用于处理输入和输出的工具集合。Java的IO框架提供了多种类和方法，用于处理不同类型的输入和输出操作。在实际应用中，根据不同的需求和使用场景，可以选择适合的类和方法进行输入和输出操作。在Java中，输入/输出（I/O）是通过流（Stream）来实现的。流是一种处理数据的抽象方式，它允许程序以连续的方式读取或写入数据。Java提供了多种类型的流，用于处理不同类型的数据和进行不同类型的I/O操作。
java IO总结 一篇很不错的
u011494298的博客
09-11 400
分类一：按操作方式（类结构） 字节流和字符流： 字节流：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据。 字符流：以字符为单位，每次次读入或读出是16位数据。其只能读取字符类型数据。 输出流和输入流： 输出流：从内存读出到文件。只能进行写操作。 输入流：从文件读入到内存。只能进行读操作。 注意：这里的出和入，都是相对于系统内存而言的。 节点流和处理流： 节点流：直接与数据源相连，读入或读出。 处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节
【Java】Java的I/O框架
yao_yaoya的博客
11-30 545
IO流的概念：内存与存储设备之间传输数据的通道。数据借助流传输。
java中的new BufferedReader(new InputStreamReader(System.in))
a1k2l45k的博客
12-26 1621
new BufferedReader(new InputStreamReader(System.in))
Java知识点总结——IO流框架
mxy2404830的博客
12-11 334
IO框架 一、流的概念 概念：内存与存储设备之间传输数据的通道。 二、流的分类 按方向分类： 输入流：将<存储设备>中的内容读入到<内存>中 输出流：将<内存>中的内容读入到<存储设备>中 内存：内存是一种用于暂时存放[CPU]中的运算数据和外部储存器交换数据的随机储存器。 存储：一般可分为机械[硬盘]和[固态硬盘]，是一种储存硬件，用于存放数据。 按单位进行划分： 字节流：以字节为单位，可以读写所有数据。 字符流：以字符为单位，只
Java入门到精通.md
07-11
最全面的Java笔记从不会到入门，从入门到精通 ，有源码讲解 以及代码中含有详细的注释便于你的理解，让你对Java学习不那么难。
Java基础详解（入门级）
04-19
第七章：集合框架（容器）+其他类对象使用 139-199 第八章：IO 流 199-280 第九章：GUI 编程 280-284 第十章：网络编程 284-309 第十一章：反射机制 310-315 第十二章：正则表达式 315-322 第十三章：HTML ...
免费超全面的Java基础类型，容器，并发，IO流，面向对象，Web编程等代码总结
最新发布
10-31
Java基础类型，容器，并发，IO流，面向对象，Web编程等代码总结。 2、分类文档 JVM虚拟机 JVM特点，结构与执行周期 JVM类加载机制 JVM运行时区数据 JVM执行引擎和垃圾回收 基础语法 理解Java中对象基础Object类 ...
Android开发应用实战详解源代码
12-31
4.10 用.iava.io.file实现文件搜索 4.11 置换imagebutton按钮 4.12 实现autocompletetextview输入提示 4.13 实现analogclock时钟 4.14 时间选择 4.15 progressbar和handler进度条 4.16 动态排版处理 4.17 ...
java高手真经 光盘源码
02-13
javaio.zip 09.Java输入/输出流 javavi.zip 09.Java输入/输出流上机作业参考（文本编辑器） javathread.zip 10.Java多线程编程（线程池、生产者消费者、存取款实例） javautil.zip 11.Java常用实体类 javaxml....
Java IO框架 commons-io-2.11.0
06-22
Java IO框架 commons-io-2.11.0
BufferedWriter和BufferedReader的使用
smileLs的博客
06-18 442
BufferedWriter和BufferedReader的使用
二、JAVA IO流 框架体系
shiyu_951的博客
07-25 554
一、JAVA　IO流框架体系 （java.io）
JavaIO框架​​​​
qq_57216731的博客
12-05 389
流 字节流抽象类
java缓冲流，BufferedReader,BufferedWriter 详解
tuke_tuke的博客
08-04 3918
缓冲流，BufferedReader,BufferedWriter 1）BufferedReader,BufferedWriter是更高级的流，二者的源和目的地必须是字符输入流和字符输出流.如果把字符输入流做为BufferedReader流的源，把字符输出流作为BufferedWriter流的目的地，那么BufferedReader,BufferedWriter将有更强的读、写能力。//构造函数
java 异步io 框架_基于 Java NIO 的异步 IO 框架 BaseIO
weixin_39564187的博客
02-19 163
软件介绍BaseIO是基于java nio开发的一款可快速构建网络通讯项目的异步IO框架，其以简单易用的API和优良的性能深受开发者喜爱。项目特色支持协议扩展，已知的扩展协议有：Redis协议(仅作测试)，示例：详见 {baseio-test}LineBased协议(基于换行符的消息分割)，示例：详见 {baseio-test}FixedLength协议(固定长度报文头)，支持传输文本和二进制数据...
java io 框架_java io框架详解
weixin_39604350的博客
02-12 151
一. IO的分类从数据来源或者说是操作对象角度看,IO 类可以分为:1. 文件(file)：FileInputStream、FileOutputStream、FileReader、FileWriter2. 管道操作：PipedInputStream、PipedOutputStream、PipedReader、PipedWriter3. 数组([]):字节数组(byte[])：ByteArrayIn...
Java中的IO框架
qq_44719987的博客
10-10 348
什么是流？ 内存与存储设备之间传输数据的通道 流的分类 输入流：将<存储设备>中的内容读入到<内存> 输出流：将<内存>中的内容写入到<存储设备>中 字节流：以字节为单位，可以读写所有数据 字符流：以字符为单位，只能读写文本数据 节点流：具有实际传输数据的读写功能 过滤流：在节点流的基础之上增强功能 ...
java异步io_Java 异步 IO
weixin_30419759的博客
02-12 130
新的异步功能的关键点，它们是Channel 类的一些子集，Channel 在处理IO操作的时候需要被切换成一个后台进程。一些需要访问较大，耗时的操作，或是其它的类似实例，可以考虑应用此功能。在这里，我们只单独讲解针对文件IO操作的 AsynchronousFileChannel，但是需要注意的是，还有一些其他的异步管道。这里包括：AsynchronousFileChannel：针对文件；Async...
java 搜索_Java实现搜索功能代码详解
06-10
实现搜索功能的代码需要涉及到前端页面和后台Java代码。下面是一个简单的例子，可以用作参考： 1. 前端代码： ``` <!DOCTYPE html> 搜索 搜索"> ``` 2. 后台Java代码： ``` import java.io....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值