java使用I/O操作文件

最新推荐文章于 2022-09-06 15:55:52 发布

病妖

最新推荐文章于 2022-09-06 15:55:52 发布

阅读量242

点赞数 2

分类专栏： Java高级API 文章标签： java API 字符串

本文链接：https://blog.csdn.net/weixin_42507474/article/details/107768874

版权

Java高级API 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、操作文件或目录属性

关于File的构造方法

方法	说明
File(String pathname)	用指定的文件路径构造文件
File(String dir,String subpath)	在指定的目录下创建指定文件名的路径
File(File parent,String subpath)	根据一个文件对象和一个字文件构造文件对象parent参数指定目录文件，subpath参数指定文件名

关于File类的常用方法

方法	说明
boolean exists	测试文件是否存在
String getAbsolutePath()	返回此对象表示的文件的绝对路径
String gerName()	返回此对象表示的文件的名称
String gerParent()	返回此File对象的路径名的上一级，如果路径名没有上一级，则返回null
boolean delete()	删除此对象指定的文件
boolean createNewFile()	创建空文件，不创建文件夹
boolean isDirectory	测试次File对象表示的是否是目录
boolean mkdir	创建一个目录，它的路径名由当前File对象指定
boolean mkdirs	包括父目录的目录

使用File类操作文件和目录属性的步骤一般如下
1）引入File类
impot java.io.file
2）创建一个文件对象
File file = new File(“text.txt”)
3）利用访问File类的方法访问文件或目录的属性
file.exists
…
示例：使用File类创建和删除文件
实现步骤：

引入File类
构造一个文件对象
调用File的方法创建和删除文件

package date;

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

public class Test3 {
    //使用File类创建和删除文件
    public static void main(String[] args) throws IOException {
        Test3 t = new Test3();
        File f = new File("C:\\Users\\86177\\Desktop\\test.txt");
        t.create(f);
//        t.delete(f);

    }

   public void create(File file) throws IOException {
        if (!file.exists()){
            file.createNewFile();
        }
       System.out.println("文件创建成功");
    }

   public void delete(File file) {
        if (file.exists()){
            file.delete();
        }
    }
}

二、认识java的流

概述：

读文件是指把文件中的数据读取到内存中。反之，写文件就是把内存中的数据写到文件中。而流就是来读写文件的。
流是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道
流分为输入流和输出流，输入/输出流是相对于计算机内存来说的，如果数据输入到内存，则称为输入流，反之就是输出流。Java的输出流主要由OutputStream和Write作为基类，而输入流则主要由InputStream和Reader作为基类，，字符流最适合用来处理字符串和文本
在java.io包中，封装了许多输入/输出流的API。在程序中，这些输入/输出流类的对象称为流对象。可以通过这些流对象将内存中的数据以流的方式写入文件，当然也可以通过流对象将文件中的数据以流的方式读取到内存
构造流对象时往往会和数据源（如文件）联系起来。数据源分为源数据源和目标数据源，输入流关联的是源数据源，输出流关联的则是目标数据源。

字节流是8位通用字节流，其基本单位是字节，字节流的基类是InputStream类和OutputStream类，他们是抽象类
字符流是16位Unicode字符流，基本单位是Unicode字符字符流最适合用来处理字符串和文本，他们也是抽象类。

一个被访问的流的基本特征都是通过实现这4个抽象类的方法来建立的。
inputStream类的常用方法

方法	说明
int read()	从输入流中读取下一个字节数据
int read(byte[] b)	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的字节数
int read(byte[] b,int off,int len)	从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始
void close	关闭输入流

OutputStream类的常用方法

方法	说明
void write(int c)	将指定的字节数据写入此输出流中
void write(byte[] buf)	将数组buf中的所有字节写入此输出流中
void write(byte[] b,int off,int len)	将字节数组中从偏移量off开始的长度为len的字节数据输出到输出流中
void close()	关闭输出流

Reader类的常用方法

方法	说明
int read()	从输入流中读取单个字符，返回所读取的字符数据
int read(byte[] c)	从输入流中最多读取c.length个字符，保存到字符数组c中，返回实际读取的字符数
int read(char[] c ,int off,int len)	从输入流中读取最多len个字符，保存到字符数组c中，保存的位置从off位置开始，返回实际读取的字符数
void close()	关闭流

Write类的常用方法

方法	说明
void write(String str)	将str字符串里包含的字符输出到指定的输出流中
void write(String str,int off,int len)	将str字符串里从off位置开始，长度为len的多个字符输出到输出流中
void close()	关闭输出流
void flush()	刷新输出流

注意：
1.在操作上字节流与字符流有一个区别，字符流在操作时使用了缓冲区（内部存储器），而字节流在操作时直接操作文件，不会使用缓冲区。
2.所有的这些方法在出现错误时都会出现IOException异常。

三、读写文本文件

通常可以使用java.io包里的流读写文本文件

1.使用字节流读写文本文件

1）使用字节流类FileInputStream读文本文件
FilInputStream称为文件输入流，它是字节输入流InputStream抽象类的一个字类，它的作用是将文件中的数据输入到内部存储器（简称内存）中，可以利用它来读取文本文件中的数据，其具体实现步骤如下：

导入相关的类
构造一个文件输入流对象
利用文件输入流的方式读取文本文件的数据
关闭文本文件输入流对象

示例：使用FileInputStream类读取文本文件的数据
实现步骤：
1.引入相关类
2.在一盘中创建目录和文件，并在文件中输入内容
3.创建流对象
4.调用read方法读取数据
5.关闭流对象

import java.io.IOException;

public class Test4 {
    //使用FileInputStream类读取文本文件的数据
    public static void main(String[] args) throws IOException {
        //创建流对象
        FileInputStream f = new FileInputStream("C:\\Users\\86177\\Desktop\\test.txt");
        int data;
        System.out.println("可读取的字节数："+f.available());
        System.out.print("文件内容为：");
        //循环读数据
        while ((data=f.read())!=-1){
            System.out.print(data+"");
        }
        //关闭流对象
        f.close();
    }
}

注意：
read()方法返回整数，如果读取的是字符串，需进行强制类型转换
流对象使用完毕后需要关闭

2.使用字节流FileOutputStream写文本文件

FileOutputStream称为文件输出流，它是字节输出流OutputStream抽象类的子类。它的作用是把内存中的数据输出到文件中，可以利用它把内存中的数据写入到文本文件中。具体实现步骤如下：

引入相关的类
构建一个文件输出流对象
利用文件输出流的方法把数据写入到文本文件中
关闭文件输出流

示例：使用FileOutputStream类向文本文件中写入数据
实现步骤：
1.引入相关类
2.创建流对象
3.调用write方法写入数据到文件中
4.关闭流对象

import java.io.FileOutputStream;

public class Test5 {
    //使用FileOutputStream类向文本文件中写入数据
    public static void main(String[] args) {
        try{
            String str = "好好学习Java";
            byte[] words=str.getBytes();//字节数组、
            //创建流对象，以追加方式写入文件
            FileOutputStream f = new FileOutputStream("C:\\Pratice\\jdbc\\src\\doc\\新建文本文档.txt",true);
            //写入文件
            f.write(words,0,words.length);
            System.out.println("文件已经更新");
        } catch (java.io.IOException e) {
            System.out.println("创建文件时出错！");
        }
    }
}

代码FileOutputStream f = new FileOutputStream(“C:\Pratice\jdbc\src\doc\新建文本文档.txt”,true);第二个参数为true，表示在文件末尾添加数据，否则默认情况下，向文件写数据时将覆盖文件中的内容。在写入第二个参数true后，如果文件不存在，程序运行后，将首先创建此文件然后写入数据

注意

1.在创建FileOutputStream实例时，如果相应的文件并不存在，就会自动创建一个空的文件夹
2.如果参数file或name表示的文件路径存在，但是代表一个文件目录，则会抛出FileNotFoundException的异常
3.默认情况下，向文件写数据时将覆盖文件中原有的内容

3.使用字符流读写文本文件

1）使用字符狸奴类BufferedReader和FileReader读写文本文件
BufferReader类和FileReader类都是Reader抽象类的子类，它们可以通过字符流的方式读取文件，并使用缓冲区，提高了读文本文件的效率。读取文本文件的具体步骤如下：

引入相关的类
构造一个BufferedReader对象
利用BufferReader类的方法读取文本文件的数据
关闭相关的流对象

示例：使用BufferedReader类和FileReader类读取文本文件的数据
实现步骤
1.引入相关类
2.创建流对象
3.调用readLine()方法读取数据
4.关闭流对象

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

public class Test6 {
    //使用BufferReader和FileReader类读取文本文件数据
    public static void main(String[] args) {
        //创建一个FileReader对象

        try {
            FileReader    f = new FileReader("C:\\Users\\86177\\Desktop\\test.txt");
            //创建一个BufferReader对象
            BufferedReader b = new BufferedReader(f);
            //读取一行数据
            String line = b.readLine();
            while (line!=null){
                System.out.println(line);
                line=b.readLine();
            }
            //关闭流
            b.close();
            f.close();

        } catch (java.io.IOException e) {
            System.out.println("文件不存在！");
        }


    }
}

2）使用字符流BufferWriter和FileWriter来写文件
BfferedWriter和FileWriter都是字符输出流Writer抽象类的子类，他们可以通过字符流的方式并通过缓冲区把数据写入文件，提高了文件文本的效率。把数据写入文本文件的具体操作步骤如下：

引入相关的类
创建一个Buffered对象
利用BufferedWrite类的方法写文件
相关流对象的清空和关闭

示例：使用BufferedWriter及FileWriter对象向文本文件中写数据，并将写入文件的数据读取出来显示在控制台上
实现步骤：
1.引入相关类
2.创建流对象
3.调用write方法写入数据
4.调用flush方法刷新缓冲区
5.读取写入的数据
5.关闭流对象

package date;

import java.io.*;

public class Test7 {
    //示例：使用BufferedWriter及FileWriter对象向文本文件中写数据，
    // 并将写入文件的数据读取出来显示在控制台上
    public static void main(String[] args) throws IOException {
        //创建FileWriter对象
        FileWriter f = new FileWriter("C:\\Pratice\\jdbc\\src\\doc\\新建文本文档.txt");
        //创建一个BufferedWriter对象
        BufferedWriter b = new BufferedWriter(f);
        //写入信息
        b.write("大家好！" );
        b.write("我是ig的ad泡芙");
        b.newLine();
        b.write("被0-3我感觉心情还是很开心的");
        b.newLine();
        b.flush();
        b.close();
        f.close();
       //创建一个FileReader对象
        FileReader f1 = new FileReader("C:\\Pratice\\jdbc\\src\\doc\\新建文本文档.txt");
        //创建一个BufferedReader对象
        BufferedReader b1 = new BufferedReader(f1);
        //读取数据
        String l = b1.readLine();
        while (l!=null){
            System.out.println(l);
            l = b1.readLine();
        }
        b1.close();
        f1.close();

    }
}

4.读写二进制文件

1.使用字节流读二进制文件

利用DataInputStream类读取二进制文件，其实与利用FileInputStream类读文本文件及其相似，也要用到FileInputStream类关联二进制文件。具体步骤如下：

引入相关的类
构造一个数据输入流对象
利用数据输入流类的方法读取二进制文件中的数据
关闭数据输入流

2.使用字节流写二进制文件

利用DateOutputStream类写二进制文件，其实与利用FileOutputStream类写文本文件及其相似，也要用到FilePutputStream类关联二进制文件。具体操作步骤如下：

引入相关的类
构造一个数据输出流对象
利用数据输出流类的方法把数据写入二进制文件
关闭数据输出流

3.示例：实现从一个二进制文件ReadAndWriteBinaryFile中读取数据，然后复制到另一个二进制文件中

实现步骤：
1.引入相关类
2.创建流对象
3.调用DateInputStream对象的read方法读取数据
4.调用DataOutputStream对象的write方法写数据
5.读取写入的数据
6.关闭流对象

package date;

import java.io.*;

public class Test8 {
    //实现从一个二进制文件ReadAndWriteBinaryFile中读取数据，然后复制到另一个二进制文件中
    public static void main(String[] args) throws IOException {
        //创建流对象,读二进制文件
        FileInputStream f = new FileInputStream("C:\\Pratice\\jdbc\\out\\production\\jdbc\\ChaiFen.class");
        DataInputStream d = new DataInputStream(f);
        //创建流对象，写二进制文件
        FileOutputStream f1 =  new FileOutputStream("C:\\Users\\86177\\Desktop\\hello.class");
        DataOutputStream d1 = new DataOutputStream(f1);
        int temp;
        while ((temp=d.read())!=-1){//读数据
            d1.write(temp);//数据写入
        }
        //关闭流
        f.close();
        d1.close();

    }
}

5.重定向标准I/O

在这里，还有两个特别重要的流，System.in和System.out，他们是java提供的两个标准输入/输出流，主要用于从键盘接受数据以及向屏幕输出数据。

1.System.in常见方法

int read(),此方法从键盘接受一个字节的数据，返回值是该字符的ASCII码
int read(byte []buf),此方法从键盘接收多个字节的数据，保存至buf中，返回值是接收字节数据的个数

2.System.out常见方法

print()，向屏幕输出数据，不换行，参数可以是java的任意数据类型
println()，向屏幕输出数据，换行，参数可以是java的任意数据类型

3.重定向标准I/O解释以及方法

什么是重定向标准I/O：简单的说，就是讲标准I/O重新定向到其他的I/O设备
System类提供了3个重定向标准输入/输出方法

方法	说明
static void setErr(printStream err)	重定向标准错误输出流
Static void setIn(Inputstream in)	重定向标准输入流
Static void setOut(printStream out)	重定向标准输出流

代码解释：

//创建printStream输出流
printStream ps = new PrintStream(new FileOutputStream("文件路径"));
//将标准输出流重定向到文件
System.setOut(ps);
//向文件中输出内容
System.out.print("sdifhjsl");
System.out,println(new ReOut());