Java——常用工具_IO流

最新推荐文章于 2024-07-02 00:50:11 发布
最新推荐文章于 2024-07-02 00:50:11 发布
阅读量635 收藏 1
点赞数
分类专栏： JAVA 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42873479/article/details/121652540
版权

Java——常用工具_IO流

异常处理

  1. 异常的分类（Trowable）：
    异常（Exception）：合理的应用程序可能需要捕获的问题
    错误（Error）：合理的应用程序不应该试图捕获的问题

在这里插入图片描述

  1. 异常处理方式
    try…catch(finally)：捕获，字节处理
    throws：抛出，交给调用者处理
    在这里插入图片描述

try_catch

格式：
try {
//尝试执行的代码（有可能出现问题的代码）
} catch(Exception e) {
//出现问题后的解决方案
} finally{
//写在这里的代码一定会执行，一般是用来释放资源的
}

package com.io;

public class test01 {
    public static void main(String[] args) {
        //用try catch finally 来处理异常
        try { //快捷键command+option+t
            int a = 10/0;
            System.out.println("a:" + a);
            return;  //finally一定会执行
            //如果没有错误，不会执行catch，直接finally
            //有错误，执行catch，而后finall
        } catch (Exception e) {
            System.out.println("除数不能为0");
            return;  //就算执行到了return，最终的finally语句也会执行
        } finally {
            System.out.println("执行了吗？");
        }
    }
}

执行流程：
先执行try{}中的内容，看是否有问题（异常）
没有：直接执行finally语句中的内容
有：跳转到catch(){}语句中开始执行

throws

throws是使用在方法里。

package com.io;

public class test02 {
    public static void main(String[] args) throws Exception {
        //因为调用的show()方法意见抛出了一个异常，作为调用者（main）函数必须处理这个异常
        //所以方案一是在main函数中继续抛出异常，会返回个JVM的
        //show();
        //方案二：采用try catch处理
        try {
            show();
        } catch (Exception e) {
            System.out.println("有异常抛出");
        }
    }
    public static void show() throws Exception{
        int a = 10/0;
        System.out.println("a:" + a);
    }
}

IO流概述

IO流的分类：
按数据流向分：输入流、输出流
按操作方式分：
字节流：InputStream\OutputStream
字符流：Reader\Writer
IO流体系：
字符流：按字符读写数据的IO流
在这里插入图片描述

字节流：按字节读写数据的IO流
在这里插入图片描述

在这里插入图片描述

File类

  1. 简介
    文件，文件夹，一个File对象代表磁盘上的某个文件或文件夹
  2. 构造方法
    File(String pathname)
    File(String parent, String child)
    File(File parent, String child)
  3. 成员方法
    （1）createNewFile()：创建文件
    （2）mkdir()和mkdirs()：创建目录
    （3）isDirectory()：判断File对象是否为目录
    （4）isFile()：判断File对象是否为文件
    （5）exists()：判断File对象是否存在
package com.io;

import java.io.File;
import java.io.IOException;

public class test03 {
    public static void main(String[] args) throws IOException {
        //将lib.1.txt封装成File对象
        //方式一：根据字符串形式的路径获取File对象
        //File file1 = new File("lib\\1.txt");
        File file1 = new File("lib/1.txt");
        System.out.println("file1:" + file1);
        //方式二：根据字符串形式的父目录以及子目录创建File对象
        File file2 = new File("lib", "1.txt");
        System.out.println("file2:" + file2);
        //方式三：根据父母路对象，以及字符串形式的子目录来获取File对象
        File file3 = new File("lib");
        File file4 = new File(file3, "1.txt");
        System.out.println("file4:" + file4);

        //在目录下创建2.txt文件
        File file5 = new File("/Users/yu/Downloads/java/2.txt");
        boolean flag1 = file5.createNewFile();
        System.out.println("flag1:" + flag1);  //flag1:true  第二遍再执行就是false了
        //在目录下创建文件夹a
        File file6 = new File("/Users/yu/Downloads/java/a");
        boolean flag2 = file6.mkdir();
        System.out.println("flag2:" + flag2);  //flag2:true
        //在目录下创建a/b/c文件夹
        File file7 = new File("/Users/yu/Downloads/java/a/b/c");
        boolean flag3 = file7.mkdirs();
        System.out.println("flag3:" + flag3);

        //测试判断功能
        File file8 = new File("/Users/yu/Downloads/java/a/b");
        System.out.println("测试file8是否是文件夹：" + file8.isDirectory()); //测试file8是否是文件夹：true
        System.out.println("测试file8是否是文件：" + file8.isFile()); //测试file8是否是文件：false
        System.out.println("测试file8是否存在：" + file8.exists());  //测试file8是否存在：true
    }
}

（6）getAbsolutePath()：获取绝对路径
（7）getPath()：获取文件的相对路径
（8）getName()：获取文件名
（9）list()：获取指定目录下所有文件（夹）名称数组
（10）listFiles()：获取指定目录下所有文件（夹）File数组

package com.io;

import java.io.File;

public class test04 {
    public static void main(String[] args) {
        File file1 = new File("lib/1.txt");
        //获取file1的绝对路径
        String path1 = file1.getAbsolutePath();
        System.out.println("绝对路径:" + path1);
        //获取file1的相对路径
        String path2 = file1.getPath();
        System.out.println("相对路径：" + path2);
        //获取文件名
        String fileName = file1.getName();
        System.out.println("文件名：" + fileName);
        //获取lib文件夹下所有的文件（夹）的名称数组String[]
        File file2 = new File("/Users/yu/Downloads/java");
        String[] names = file2.list();
        for (String name : names) {
            System.out.println(name);
        }
        //获取lib文件夹下所有的文件（夹）的File对象数组 File[]
        File[] files = file2.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

字符流读写文件

字符流读数据

  1. 按单个字符读取
    （1）创建字符流读文件对象：Reader reader = new FileReader(“1.txt”);
    （2）调用方法读取数据：
    int data = reader.read(); 读取一个字符，返回该字符代表的整数，若大道流的末尾，返回-1。
    （3）异常处理：throws IOException
    （4）关闭资源：reader.close();
package com.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class test05 {
    public static void main(String[] args) throws IOException {
        //通过字符流读取数据 FileReader()
        //1.创建字符输入流对象
        FileReader reader = new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt");
        //2.读取数据
//        int ch1 = reader.read();
//        System.out.println(ch1); //97
//        int ch2 = reader.read();
//        System.out.println(ch2); //98
//        int ch3 = reader.read();
//        System.out.println(ch3); //99
//        int ch4 = reader.read();
//        System.out.println(ch4); //-1
        //使用while循环读取
        //定义变量，用来接收读到的字符
        int ch;
        //读取，赋值，判断是否打印
        while ((ch = reader.read()) != -1) {
            System.out.println(ch);
        }
        reader.close
    }
}
  1. 按字符数组读取
    （1）创建字符流读文件对象
    （2）调用方法读取数据
    int read(char[] chs) ：一次读一个字符数组，将读到的内容存入到数组中，并返回读取到的有效字符数，读不到返回-1
    （3）异常处理
    （4）关闭资源
package com.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class test06 {
    public static void main(String[] args) throws IOException {
        //通过字符流读取数据，一次读取一个字符数组  1.txt: abcdefg
        //1.创建字符输入流对象
        FileReader reader = new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt");
        //2.读取数据
        //int read(char[] chs) 一次读一个字符数组，将读到的内容存入到数组中，并返回读取到的有效字符数，读不到返回-1
//        char[] chs = new char[3];
//        int len1 = reader.read(chs);
//        System.out.println(chs);    //abc
//        System.out.println(len1);   //3
//
//        int len2 = reader.read(chs);
//        System.out.println(chs);   //def
//        System.out.println(len2);  //3
//
//        int len3 = reader.read(chs);
//        System.out.println(chs);   //gef  因为之前容器里是def，最后只剩下一个f，覆盖了g，所以说gef
//        System.out.println(len3);  //1
        //使用while循环
        //定义字符数组
        char[] chs = new char[3];
        int len; //定义读取到的有效字符数
        while ((len = reader.read(chs)) != -1) {
            String s = new String(chs, 0, len);
            System.out.println(s);
        }
//        abc 
//        def
//        g
        //3.释放资源
        reader.close();
    }
}

字符流写数据

  1. 按字符数组写入
    （1）创建字符流写文件对象
    （2）调用方法写入数据：写入一个字符. void write(int ch)
    （3）异常处理
    （4）关闭资源
  2. 按字符数组写入
    （1）创建字符流写文件对象
    （2）调用方法写入数据：写一个字符数组. void write(char[] chi, int index, int len)
    （3）异常处理
    （4）关闭资源
  3. 按字符串写入
    （1）创建字符流写文件对象
    （2）调用方法写入数据：写一个字符串. void write(String str)
    （3）异常处理
    （4）关闭资源
package com.io;

import java.io.FileWriter;
import java.io.IOException;

public class test07 {
    public static void main(String[] args) throws IOException {
        //通过字符流，写数据
        //1.创建字符输出流对象
        FileWriter writer = new FileWriter("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/2.txt");
        //2.写数据
        //一次写一个字符
        writer.write("好");

        //一次写一个指定的字符数组
        char[] chs = {'好', '天', '气'};
        writer.write(chs, 0, 2); //从索引0开始，读取两个

        //一次写一个字符串
        writer.write("好好学习");
        //3.释放资源
        writer.close();
    }
}

字符流拷贝文件

  1. 按单个字符读写
    （1）创建字符流读文件对象
    （2）创建字符流写文件对象
    （3）调用方法读取数据：int data = reader.read()
    （4）调用方法写入数据
    （5）异常处理
    （6）关闭资源
package com.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class test08 {
    public static void main(String[] args) throws IOException {
        //通过字符流拷贝文件，一次读写一个字符
        //将1.txt文件中的内容复制到2.txt
        /* control+shift+/
        IO流拷贝文件核心六步：
                1.创建字符输入流对象，关联数据源文件
                2.创建字符输出流对象，关联目的地文件
                3.定义变量，记录读取到的内容
                4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给遍历
                5.将读取到的数据写入到目的地文件
                6.释放资源
        */
        FileReader fr = new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt");
        FileWriter fw = new FileWriter("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/3.txt");
        int len;
        while ((len = fr.read()) != -1) {
            fw.write(len);
        }
        fr.close();
        fw.close();
    }
}
  1. 按字符数组读写
    （1）创建字符流读文件对象
    （2）创建字符流写文件对象
    （3）调用方法读取数据：
    char[] chs = new char[2048];
    int len = reader.read(chs);
    （4）调用方法写入数据：writer.write(chs, 0, len)
    （5）异常处理
    （6）关闭资源
package com.io;

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

public class test09 {
    public static void main(String[] args) throws IOException {
        //通过字符流拷贝文件，一次读写一个字符数组
        FileReader fr = new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt");
        FileWriter fw = new FileWriter("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/3.txt");
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read()) != -1) {
            fw.write(chs, 0, len);
        }
    }
}

缓冲流普通用法

用法和前面类似，只是创建的对象不同。

  1. 字符缓冲流普通用法
package com.io;

import java.io.*;

public class test10 {
    public static void main(String[] args) throws IOException {
        //通过字符缓冲流，将1.txt文件中的内容拷贝到2.txt中
        //1.创建字符缓冲流对象，关联数据源文件
        //1.1 普通的字符输入流对象
        FileReader fr = new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt");
        //1.2 字符缓冲输入流对象
        BufferedReader br = new BufferedReader(fr);
        //简单写法
        //BufferedReader br = new BufferedReader(new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt"));

        //2. 创建字符缓冲输出流对象，关联目的地文件
        //2.1 创建普通的字符输出流对象
        FileWriter fw = new FileWriter("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/2.txt");
        //2.2 创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(fw);

        //3. 定义变量，记录读取到的数据
        int len;
        //4. 循环读取，赋值写入
        while ((len = br.read()) != -1) {
            bw.write(len);
        }
        //6. 释放资源
        br.close();
        bw.close();
    }
}

字符缓冲流自带有缓冲区，大小为8192个字符，也就是16KB。
2. 字符缓冲流之一次读写一行

package com.io;

import java.io.*;

public class test11 {
    public static void main(String[] args) throws IOException {
        //通过字符缓冲流"一次读写一行"的方式，将1.txt文件中的内容拷贝到2.txt文件中
        //1. 创建字符缓冲输入流对象，关联数据源文件
        BufferedReader br = new BufferedReader(new FileReader("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.txt"));
        //2. 创建字符缓冲输出流对象，关联目的地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/2.txt"));
        //3. 定义变量，记录读取到的内容
        String str;
        //4. 循环读取
        while ((str = br.readLine()) != null) {
            //5. 写入数据
            bw.write(str);
            //记得换行
            bw.newLine();
        }
        //6. 释放资源
        br.close();
        bw.close();
    }
}

字节流读写文件

在这里插入图片描述

字节流拷贝文件

  1. 按单个字节读写
    （1）创建字节流读文件对象
    （2）创建字节流写文件对象
    （3）异常处理
    （4）使用while循环读写数据：write(int len)一次写入一个字节
    （5）关闭资源
package com.io;

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

public class test12 {
    public static void main(String[] args) throws IOException {
        //通过普通的字节流，一次读写一个字节的方式，将a.jpg复制到b.jpg
        FileInputStream fis = new FileInputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.jpg");
        FileOutputStream fos = new FileOutputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/2.jpg");
        int len;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }
        fis.close();
        fos.close();
    }
}
  1. 按字节数组读写
    （1）创建字节流读文件对象
    （2）创建字节流写文件对象
    （3）异常处理
    （4）定义字节数组，每次读写1024、2048个字节 byte[] b = new byte[2048];
    （5）使用while循环读写数据 ：write(byte[] bye, int index, int len) 一次写入一个指定的字节数组
    （6）关闭资源
package com.io;

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

public class test13 {
    public static void main(String[] args) throws IOException {
        //通过字节流一次写一个字节数组的方式，将1.jpg复制到3.jpg
        FileInputStream fis = new FileInputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.jpg");
        FileOutputStream fos = new FileOutputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/3.jpg");
        byte[] bys = new byte[2048];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        fis.close();
        fos.close();
    }
}

字节缓冲流拷贝文件

字节缓冲流有自己的缓冲区，大小为8192个字节，也就是8KB。

package com.io;

import java.awt.image.BufferedImage;
import java.io.*;

public class test14 {
    public static void main(String[] args) throws IOException {
        //通过字节缓冲流，复制字节文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/1.jpg"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/Users/yu/IdeaProjects/JavaSE/基础语法/lib/4.jpg"));
        int len;
        while ((len = bis.read()) != -1) {
            bos.write(len);
        }
        bis.close();
        bos.close();
    }
}
糖糖Amor
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java——IO流
weixin_44146372的博客
09-21 263
字节流、字符流、缓冲流、转换流、对象流等等 IO 操作🌌
10.JAVA之IO流、泛型、集合、List
weixin_56027329的博客
04-13 305
JAVA之IO流(字符流和字节流)、泛型、集合Collection、List、ArratList。
JAVA之常用的工具类
热门推荐
上善若泪
04-16 3万+
目录 1 org.apache.commons.io.IOUtils 2 org.apache.commons.io.FileUtils 3org.apache.commons.lang.StringUtils 4 org.apache.http.util.EntityUtils 5 org.apache.commons.lang3.StringUtils 6 org.apache....
大数据Java强化班(八)之IO流
08-30
课程由猎豹移动大数据架构师，根据Java在公司大数据开发中的实际应用，精心设计和打磨的大数据必备Java课程。通过本课程学习大数据新手能够少走弯路，以最短的时间系统掌握大数据开发必备语言Java，为后续大数据课程的学习奠定了坚实的语言基础。课程特色1.课程是由猎豹移动大数据架构师亲自授课2.课程理论讲解透彻形象，手把手实战操作3.课程包含大数据开发必备的所有Java知识4.课程前后连贯、系统完整，不会出现跳讲和断讲技术说明1. 语言版本：JDK1.82. 开发工具：Eclipse课程资料免费提供完整的PPT资料免费提供完整的Word文档免费提供完整的随堂笔记免费提供完整的课程代码免费提供完整的软件包
IO流工具类
Kris_Liu
10-18 505
package com.lt.an20_utils;import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayInputStream; imp
java常用工具类——个人总结
12-22
以下是我个人对Java中常用工具类的总结，主要涉及了加密、文件上传和日期处理等核心领域。 1. **加密工具类**： - `java.security` 包下的 `MessageDigest` 类用于实现消息摘要算法，如MD5和SHA，常用于数据完整性...
java io流学习笔记1
04-18
Java IO流是Java平台中用于处理输入输出操作的重要机制，它是Java编程中不可或缺的一部分。在本文中，我们将深入探讨Java IO流的基本概念、类型、以及它们在实际开发中的应用。 一、基本概念 Java IO流可以理解为...
Programmation_Orientée_Objet_Java_2020-2021_java_Java_OOP_
10-02
10. **IO流**：了解输入输出流的分类，文件操作，字符流和字节流的区别，以及缓冲区的概念。 11. **多线程**：探讨Java中的线程创建和同步机制，如synchronized关键字，Thread类，Runnable接口，以及并发库...
java-ppt.rar_java .ppt_java ppt_java基础 ppt_java基础 ppt_ppt jav
09-21
1. **Java环境搭建**：包括下载JDK（Java Development Kit），设置环境变量如JAVA_HOME, PATH, CLASSPATH，以及如何运行第一个Java程序——经典的"Hello, World!"。 2. **语法基础**：包括数据类型（基本类型如int,...
java面试——深圳-商汤科技-Java高级.zip
09-26
7. **IO/NIO/BIO**：理解Java的输入输出模型，包括BufferedReader、FileInputStream等基本IO流，以及非阻塞IO（NIO）和BIO的区别和应用场景。 8. **网络编程**：理解TCP/IP协议，会编写Socket编程，了解HTTP协议，...
java工作6年积累常用工具类,可以快速解决日常开发各种问题
05-31
java工作6年积累常用工具类,可以快速解决日常开发各种问题，涵盖线程、网络、DB、文件、IO流、邮件、Linux远程登录、加密解密、定时任务、XML解析、JOSN解析、CVS和Excel解析、中英文转换等等
IO流工具组件
08-02
IO流工具组件 1 1 1 1 1 1
Java常用工具类之IO流工具类
weixin_34409357的博客
01-18 973
package com.wazn.learn.util; import java.io.Closeable; import java.io.IOException; /** * IO流工具类 * * @author yangzhenyu * */ public class IOUtil { /** * 关闭一个或多个流对象 ...
java 工具类之io流_IO流（IO流的工具类、Properties类）
weixin_36451983的博客
02-26 237
1、IO流的工具类(1)需要先导入jar包：(2)FilenameUtils：import org.apache.commons.io.FilenameUtils;public classFilenameUtilesDemo {public static voidmain(String[] args) {String name= FilenameUtils.getExtension("001.tx...
JAVA——IO流进阶：功能流与commonsio工具类
Numtheun的博客
06-16 301
JAVA——IO流进阶：功能流与commonsio工具类 一，功能流(处理流) 功能流是为增强、提升性能的，本身不具备直接操作节点的能力。 1.1 Buffered缓存流 功能流的一种: 缓冲流: 增强功能,提高性能 使用: 功能流(节点流) 字节缓冲流: 字节输入缓冲流 BufferedInputStream 字节输出缓冲流 BufferedOutputStream 无新增方法,可以发生多态 字符缓冲流: BufferedReader 新增方法 readLine() 读取一行 BufferedWriter
Java学习笔记11 IO流
daochutoudaima的博客
08-03 742
IO流
Java IO流学习总结七：Commons IO 2.5-FileUtils
weixin_30872789的博客
02-14 144
Java IO流学习总结七：Commons IO 2.5-FileUtils 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54972773 本文出自【赵彦军的博客】 在上面的几篇文章中，介绍了IO的常规用法，今天介绍Commons IO框架的使用。 Commons IO简介 Apache Commons IO是Apache基...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
最新发布
m0_61086522的博客
07-02 1216
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值