Java-IO篇

最新推荐文章于 2024-08-05 14:30:05 发布
最新推荐文章于 2024-08-05 14:30:05 发布
阅读量94 收藏
点赞数 1
分类专栏： Java SE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35597246/article/details/108812964
版权

Java-IO流

IO流定义

  • File类用来描述一个文件或者目录，通过File对象可以读取文件或者目录的属性数据，如果需要读取文件的内容数据，需要使用IO技术。
  • IO流分类：
    • 按照数据流向分类：输入流和输出流（以程序为标准）
    • 按照处理单位分类：字节流和字符流。
      • 字节流：读取的是文件中不经任何处理的二进制数据
      • 字符流：字符流读取的数据以字符为单位，字符流也是读取文件中的二进制数据，不过会把二进制数据转化为字符。(字符流 = 字节流+解码)
    • 按照处理的功能位置划分：节点流(Inpuestream和OutStream)和处理流(BufferedInputStream和BufferedOutputStream)。

File类

  • File常用使用方法:

    package file;

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

public class UseFile {

    public static void main(String[] args) {
        //创建File对象
        File file = new File("src/a.txt");
        //判断文件是否存在，如果不存在，创建文件
        new UseFile().createFile(file);
        //删除文件
        //new UseFile().deleteFile(file);
        //获取文件属性
        new UseFile().getFileProperty(file);
        //判断是文件还是目录
        new UseFile().judgeFileOrDir(file);
        //列出目录下的所有文件
        //new UseFile().listFile();
        //修改文件名称
        new UseFile().updateFileName(file);

    }

    public void createFile(File file){
        //文件不存在，创建文件
        if(!file.exists()){
            try {
               if(file.createNewFile()){
                   System.out.println("文件创建成功");
               }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        else{
            System.out.println("文件已存在，创建失败");
        }
    }

    //file.deleteOnExit()--等待JVM退出后，在删除文件
    public void deleteFile(File file){
        if(file.exists()){
            if(file.delete()){
                System.out.println("文件删除成功");
            }
        }
        else{
            System.out.println("文件不存在");
        }
    }

    public void getFileProperty(File file){
        //获取文件名
        String fileName = file.getName();
        System.out.println(fileName);
        //获取父文件名
        String name = file.getParent();
        System.out.println(name);
        //获取相对路径
        String relaPath = file.getPath();
        System.out.println(relaPath);
        //获取绝对路径
        String absoPath = file.getAbsolutePath();
        System.out.println(absoPath);
    }

    public void judgeFileOrDir(File file){
        if(file.isFile()){
            System.out.println("文件");
        }
        if(file.isDirectory()){
            System.out.println("目录");
        }

    }

    public void listFile( ){
        File file = new File("E:\\Java Project\\Java\\File\\res");
        //当前目录下的所有文件或目录
        File[] files = file.listFiles();
        for (File file1 : files) {
            if(file1.isDirectory()){
                System.out.println("目录："+file1.getName());
            }
            else{
                System.out.println("文件："+file1.getName());
            }
        }

    }

    public void updateFileName(File file){

        file.renameTo(new File("src/b.txt"));
    }

}

FileInputStream类

  • InputStream类是所有输入字节流的基类 抽象类。FileInputStream类读取文件的输入字节流。

  • 使用FileIInputStream类读取文件数据的步骤：

    • 找到目标文件
    • 建立数据输入通道
    • 读取文件数据：read()
    • 关闭输入流

FileOutputStream类

  • 使用FileIOutputStream类读取文件数据的步骤：

    • 找到要写入的目的文件
    • 准备写入的字节数据
    • 数据写入到文件中：write()
    • 关闭输出流

  • 将一个文件数据写入到另一个文件中

    package file;

import java.io.*;

public class ReadFile {

    public static void main(String[] args) {

        String path = "src/file/b.txt";
        String desPath = "src/file/c.txt";
        ReadFile file = new ReadFile();
        String data = file.readFile(path);
        file.writeFile(desPath,data);
    }

    //读取文件中的数据
    public String readFile(String path){
        //定义输入流
        FileInputStream inputStream = null;
        int length = -1;
        String data = "";
        try {
            inputStream = new FileInputStream(path);
            //每次处理1024字节数据
            byte byteArray[] = new byte[1024];
            while( (length = inputStream.read(byteArray)) != -1){
                data = data + new String(byteArray,0,length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                //关闭资源
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return data;
    }

    //将数据写入文件中
    public  void writeFile(String desPath,String data){
        FileOutputStream outputStream = null;
        try {

            //定义文件输出流,以追加的形式写入到目标文件中
            outputStream = new FileOutputStream(desPath,true);
            //将数据字符串转换为字节数组
            byte byteData[] = data.getBytes();
            outputStream.write(byteData);
            //清除缓冲区
            outputStream.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

处理流：文件的读取和写入

BufferedInputStream 和 BufferedOutputStream : InputStream---->BufferedInputStream ------> BufferedOutputStream---->Outputstream

package file;

import java.io.*;

public class bufferStream {
    public static void main(String[] args) {
        try {
            int length = -1;
            //定义缓冲输入流和缓冲输出流
            FileInputStream inputStream = new FileInputStream("src/file/b.txt");
            BufferedInputStream bInputStream =new BufferedInputStream(inputStream);
            FileOutputStream outputStream = new FileOutputStream("src/file/c.txt");
            BufferedOutputStream bOutputStream =new BufferedOutputStream(outputStream);
            
            while((length = bInputStream.read())!=-1){
                System.out.println(length);
                bOutputStream.write(length);
            }
            //清空缓冲区
            bOutputStream.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Charset:字符集

package file;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

public class charSetTest {
    public static void main(String[] args) {
        String str = "adsd你";
        //获取默认字符集
        System.out.println(Charset.defaultCharset());
        //获取所有支持的字符集
        System.out.println(Charset.availableCharsets());
        try {
            byte bytes[] = str.getBytes("gbk");
        //str.getBytes(Charset.forName("gbk"));
            System.out.println(new String(bytes));
            System.out.println(new String(bytes,"gbk"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

字符流（以字符为单位进行读写）

  • 加入缓冲机制读写文件：Reader---->BufferedReader---->BufferedWriter---->Writer

    package file;

import java.io.*;

public class readChar {
    public static void main(String[] args) {
        String src = "src/file/b.txt";
        String des = "src/file/c.txt";
        readChar read = new readChar();
        read.readWrite(src,des);
    }

    //以字符的形式，将一个文件中的数据写入到另一个文件中去
    public void readWrite(String src,String des){
        BufferedReader bufferReader = null;
        BufferedWriter bufferedWriter = null;

        int length = -1;
        try {
            //定义Reader和Writer以及其缓冲类
            Reader reader = new FileReader(src);
            Writer writer = new FileWriter(des);
            bufferReader = new BufferedReader(reader);
            bufferedWriter = new BufferedWriter(writer);
            //开始读写数据
            while((length = bufferReader.read())!=-1){
                bufferedWriter.write(length);
            }
            bufferedWriter.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {


        }
    }
}

字节流转换为字符流

  • 应用场景：一个GBK文件转换为UTF-8文件

  • InputStream---->InputStreamReader---->BufferedReader---->BufferedWriter---->OutputStreamWriter---->OutputStream

    package file;
import java.io.*;

public class ByteToChar {
    public static void main(String[] args) {
//        new ByteToChar().writeGBK("src/file/GBK.txt");
        new ByteToChar().gbkToUTF("src/file/GBK.txt","src/file/UTF-8.txt");
    }
    //将GBK格式的数据写入GBK文件
    public void writeGBK(String path){
        String str = "昨天、今天、明天";
        OutputStream out = null;
        try {
            byte bytes[] = str.getBytes("GBK");
            out = new FileOutputStream(path);
            out.write(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //将GBK编码的文件转换为UTF-8
public void gbkToUTF(String src,String des){
    //输入流
    InputStream input = null;
    //处理流
    InputStreamReader reader = null;
    //缓冲字符流
    BufferedReader bufferReader = null;
     //输出流
    OutputStream output = null;
    //处理流
    OutputStreamWriter writer = null;
    //缓冲字符流
    BufferedWriter bufferWriter = null;
    int length = -1;
    try{
        input = new FileInputStream(src);
        //以GBK解码文件
        reader = new InputStreamReader(input,"GBK");
        bufferReader = new BufferedReader(reader);

        output = new FileOutputStream(des);
        //写入数据，默认格式为UTF-8
        writer = new OutputStreamWriter(output);
        bufferWriter = new BufferedWriter(writer);
        while((length = bufferReader.read())!=-1)
        {
             bufferWriter.write(length);
        }
    }
    catch(IOException e){
        e.printStackTrace();
    }
    finally {
        try {
            bufferReader.close();
            bufferWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

对象流：ObjectStrem

  • 序列化：内存---->磁盘

    反序列化：磁盘---->内存

  • traisent修饰类中的属性，表示该属性不序列化

  • 类继承Serializable 接口，才能序列化。同时定义serialVersionUID，当类中的属性发生变化时，可以保证同步。

  • 类中的所有类属性，都要继承Serializable 接口。

package file;

import java.io.*;

public class ObjectStremTest {

    public static void main(String[] args) {
        String desPath = "src/file/save_class.txt";
//        new ObjectStremTest().writeObject(desPath);
        new ObjectStremTest().readObject(desPath);
    }

    //向文件中写对象
    public void writeObject(String desPath){
        ObjectOutputStream object = null;
        try {
            //定义对象流
            OutputStream output = new FileOutputStream(desPath);
            object = new ObjectOutputStream(output);
            object.writeObject(new Person("小明",13,"男"));
            object.flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                object.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    //从文件中读对象
    public void readObject(String src)
    {
        //定义对象输入流
        ObjectInputStream inputObject = null;
        try {
            InputStream input = new FileInputStream(src);
            inputObject = new ObjectInputStream(input);
            Person person = (Person) inputObject.readObject();
            System.out.println("姓名:"+person.getName()+"\t年龄:"+person.getAge()+"\t性别:"+person.getSex()+"\t地址:"+person.getAddress());
        }
        catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Java NIO

  • NIO和IO的最大区别：IO是面向流的，NIO是面向缓冲区的。IO流是阻塞的，NIO是非阻塞模式。
Files.createFile(Path.get(path))   ---->创建文件
Files.createDirectories(Path.get(path))   ---->创建目录
Files.move(Path.get(path),Path.get(path1))   --->剪切并改名
Files.delete(Path.get(path))  ---->删除文件
Files.copy(Path.get(path),Path.get(path1))   --->拷贝
Files.readAllByte(Paths.get(path))  ---- >读取文件中的内容 
Files.readAllLines(Paths.get(path))  ---->将文件内容以行的方式读出
Files.Writer(Paths.get(path),"sds".getBytes(字符集))   ---->向文件中写入数据
Files.Writer(Paths.get(path),"\nsds".getBytes(字符集),StandardOpenOption.APPEND)   ---->以追加的方式向文件中写入数据
  • Path
Path path1 = Paths.get("C:/kgc/eclipse");
Path path2 = Paths.get("C;/kgc/eclipse","eclipse.ini");
Path path3 = Paths.get("C:/","kgc/","eclipse");
  • RandomAccessFile读写文件
package file;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileTest {

    public static void main(String[] args) {
      new RandomAccessFileTest().readWriteFile("src/file/b.txt","src/file/d.txt");

    }

    //读文件
    public void readWriteFile(String src,String des){
        int length = -1;
        byte[] bytes = new byte[1024];
        try {
            //定义RandomAccessFile
            RandomAccessFile ranAccFile1 = new RandomAccessFile(src,"rw");
            RandomAccessFile ranAccFile2 = new RandomAccessFile(des,"rw");
            while ((length = ranAccFile1.read(bytes))!=-1){
//                System.out.println(new String(bytes,0,length));
                  ranAccFile2.write(bytes,0,length);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

  • commons-io:获取文件的扩展名、文件名、判断文件是否是以某某后缀名结尾、计算文件大小

  • properties :三种方式读取properties文件

    • jdk方式
    • spring的封装方式
    • Hutool的封装 方式
    package file;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) {
//       String src = "src/resources/properties/db.properties";
         new PropertiesTest().readProperties();
    }

    /**
     * 方式一：jdk方式
     */ //加载输入流
    public void readProperties()
    {
        //通过类加载器的方式获取属性的输入流
        InputStream input = PropertiesTest.class.getClassLoader().getResourceAsStream("db.properties");
        //创建Properties
        Properties properties = new Properties();
        try {
            //加载输入流
            properties.load(input);
            //通过属性，获取属性值
            System.out.println("用户名："+properties.getProperty("user"));
            System.out.println("密  码："+properties.getProperty("pwd"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


         //spring方式
     Properties properties = PropertiesLoadUtils.loadAllProperties(db.properties);
     try {
            //通过属性，获取属性值
            System.out.println("用户名："+properties.getProperty("user"));
            System.out.println("密  码："+properties.getProperty("pwd"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        /**
     * 方式二：引入Hutool包
     */
    public void hutool()
    {
        Props props = new Props("db.properties");
        //通过属性，获取属性值
        System.out.println("用户名："+props.getProperty("user"));
        System.out.println("密  码："+props.getProperty("pwd"));

    }
To-Pioneer
关注
专栏目录
JAVAのIO框架---commons-io | jar包的导入及主要API介绍
qq_53149316的博客
09-24 1459
commons-io框架jar包导入及一些API介绍
java io -- FileInputStream
zhao123h的专栏
10-15 3416
接上篇文章java io -- InputStream，本文将剖析InputStream中最常用的一个子类FileInputStream FileInputStream是对一个文件抽象而成的数据流，我们这里先展示一下这个类的结构。 图1 FileInputStream类 可以看到，这个结构和InputStream大致一致，不过多了一些特性。 首先这个类的构造函数，可以通
java之IO篇——工具包Commons-io和Hutool
2202_75483664的博客
08-05 944
结束了IO篇的File、基本流和高级流。还要认识IO流的一些工具包Commons-io和hutool，不算是框架，但是非常实用。目录前言一、Commons-io1.来历及作用2.使用二、Hutool1.简介2.使用Hutool这个工具包有很多工具类，这节我们主要说的就是IO工具类。IO工具类要说的一共有7个。
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java- IO 及其相关面试题
向诸位大佬虚心学习
07-10 5316
Java IO是Java编程中非常重要的一部分，它提供了丰富的输入和输出功能，可以实现对文件、网络和其他设备的读取和写入操作。在开发中，Java IO广泛应用于文件处理、网络通信、序列化等场景。Java IO主要涉及两个核心概念：输入流和输出流。输入流用于读取数据，输出流用于写入数据。它们支持字节流和字符流两种类型。字节流以字节为单位进行操作，适用于二进制文件或纯文本文件。字符流以字符为单位进行操作，适用于处理文本文件。Java IO还提供了标准IO和NIO两种模式。
JAVA深化篇_26——Apache commons-io工具包的使用
guojiaqi_的博客
10-31 982
Apache软件基金会（也就是Apache Software Foundation，简称为ASF），是专门为支持开源软件项目而办的一个非盈利性组织。在它所支持的Apache项目与子项目中，所发行的软件产品都遵循Apache许可证（Apache License）。 官方网址为：www.apache.org 。
Java-IO模型-详解
Java程序员的知识博客
02-06 1222
I/O 一直是很多小伙伴难以理解的一个知识点，这篇文章我会将我所理解的 I/O 讲给你听，希望可以对你有所帮助。
java基础-IO流【理论篇】
weixin_44050211的博客
09-12 770
IO流是java知识体系中很重要的一部分
【Socket----T-IO】T-IO介绍
Sunny
05-14 6825
一、什么是T-IO 1.大家口中的t-io一般是指tio-core，它是基于java aio的网络编程框架，和netty属于同类 2.基于tio-core来开发IM、TCP私有协议、RPC、游戏服务器端、推送服务、实时监控、物联网、UDP、Socket将会变得空前的简单。 3.t-io家族除了tio-core外，还有tio-websocket-server、tio-http-server、t...
Java中的IO流 - 入门篇
Li_Jian_Hui_的博客
05-12 4560
简介 文件IO流，主要有两种方式 字节流：基于各种文件，包括普通文本txt，音频文件mp3，视频文件mp4等 字符流：基于普通的文本字符串，比如普通文本txt等 本例中用到的相关类如下： 所有的读写操作都是针对内存而言的，因为程序就是运行在内存中 读操作就是从磁盘文件或网络流读到内存，对于内存而言就是Input 写操作就是从内存写到磁盘文件或网络流，对于内存而言就是Output 下面分别介绍这两种方式 字节流 本例子，字节流中主要讲的是ObjectInputStream和ObjectOut
t-io Java构建p2p网络
01-08
Java 构建p2p网络 这篇文章是一篇关于pbft算法实现的一篇补充文章，但是在这里不会涉及pbft的算法方面，所以可以当做一篇单独的文章食用。如果想查看关于区块链或者PBFT算法的文章，可以参考一下我的文章。 文章...
java高级特性 - io流.pdf
05-29
本篇内容将详细介绍Java IO流的一些关键点和具体案例。 首先，创建文件是IO流处理的一个基本操作。在Java中，可以使用File类来创建新文件。示例代码中首先导入了java.io包下的所有类，并定义了一个hello类和main...
commons-fileupload.jar和commons-io.jar
04-13
Apache Commons FileUpload和Commons IO两个库是Java中处理文件上传的关键组件，它们为SpringMVC和MyBatis这样的框架提供了强大的支持。本篇文章将深入探讨这两个库以及它们在图片处理中的作用。 首先，`commons-...
commons-io-2.9.0.jar中文-英文对照文档.zip
03-03
注：下文中的 *** 代表文件名中的组件名称。 # 包含： 中文-英文对照文档：【***-javadoc-API文档-中文(简体)... （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
毕业设计论文SpringBoot社区老人健康信息管理系统.docx
10-17
毕业设计论文
TEAM-NAVI-Requirements Specification Document
10-17
TEAM_NAVI_Requirements Specification Document
分析流体动力学中的混沌系统-解决混沌系统问题python源码+项目说明（课程作业）.zip
最新发布
10-17
1.多数小白下载后，在使用过程，可能会遇到些小问题，若自己解决不了，请及时私信描述你的问题，我会第一时间提供帮助，也可以远程指导 2.项目代码完整可靠，谈不上高分、满分(多数为夸大其词），但难度适中，满足一些毕设、课设要求，且属于易上手的优质项目，项目内基本都有说明文档，按照操作即可，遇到困难也可私信交流 3.适用人群：各大计算机相关专业行业的在校学生、高校老师、公司程序员等下载使用 4.特别是那种爱钻研学习的学霸，强烈推荐此项目，可以二次开发提升自己。如果确定自己是学渣，拿来作毕设、课设直接用也无妨，但建议自己还是尽可能弄懂项目最好！ 项目名字和项目路径不要用中文，建议解压重命名为英文名字后再运行！项目易上手运行
毕业设计论文SpringBoot教学辅助系统.docx
10-17
毕业设计论文
关于练习三的图片资源素材
10-17
电影选座精灵图
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值