搜索
简帛阁>技术文章>Java I/O流以及文件的基本操作

Java I/O流以及文件的基本操作

文件操作:

文件操作其实就是一个FIle类;我们学习文件操作就是学习File类中的方法;

文件基操:

第一部分:学习文件的基本操作(先扒源码以及文档)

Constructor Description
File(File parent, String child) 给定要操作的问价的父路径和子文件名称
File(String pathname) 给定一个要操作文件的完整路径
Modifier and Type Method Description
boolean public boolean createNewFile() throws IOException 创建文件
boolean delete() 删除文件
boolean exists() 判断给定路径是否存在

来个实例:

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

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:\\IOFileSource\\xbhog.txt");
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

createNewFile:如果指定的文件不存在且已成功创建,则为True;如果指定的文件已经存在,则为False

知识点(敲黑板):

路径分隔符:解决不同操作系统下的路径符号问题(windows->“\”;Linux->“/”);

File file = new File("e:"+File.separator +"IOFileSource"+File.separator+"xbhog.txt");

注:

/**
     * The system-dependent default name-separator character, represented as a
     * string for convenience.  This string contains a single character, namely
     * {@link #separatorChar}.
*/
public static final String separator = "" + separatorChar;

对父路径操作的方法:

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

public class FIleDelCre {
    public static void main(String[] args) throws IOException {
        File file = new File("e:"+File.separator +"IOFileSource"+File.separator+"test"+File.separator+"demo"+File.separator+"xbhog.txt");
        if(!file.getParentFile().exists()){ //如果该文件的父目录不存在
            /*
            file.getParentFile().mkdirs();   //进行创建多级父目录
            mkdirs底层进行递归调用,实现多级目录创建

            file.getParentFile().mkdir();   //进行创建一个父目录
            */
        }
        if(file.exists()){
            file.delete();
        }else{
            System.out.println(file.createNewFile());
        }
    }
}

注:mkdirs与mkdir的区别,最好进入源码中查看

文件列表显示:

流程图:

import java.io.File;
public class FilePwd {
    public static void main(String[] args) {
        File file = new File("D:" + File.separator);
		listDir(file);
    }
    public static void listDir(File file){
        if(file.isDirectory()){
            File[] Dirs = file.listFiles();
            while(Dirs != null){
                for (int i = 0; i < Dirs.length; i++) {
                    listDir(Dirs[i]);  //递归调用
                }
            }
        }
        System.out.println(file);
    }
}

文件批量更名:

情景:

在数据采集的过程中由于操作失误,使得xbhog-log文件夹下的所有文件后缀采用了.java,为了修正这一错误,要求使得该目录下的所有文件后缀统一替换成.txt,同时也需要考虑多级目录下的文件更名操作。

import java.io.File;
public class FIleChangeName {
    public static void main(String[] args) {
        File file = new File("D:" + File.separator + "xbhog-log");
        renameDir(file);

    }
    public static void renameDir(File file){
        if(file.isDirectory()){
            File[] dirs = file.listFiles(); 
            for (int i = 0; i < dirs.length; i++) {
                renameDir(dirs[i]);  //递归调用
            }
        }else {
            if (file.isFile()){ //判断是否为文件
                String fileName = null;  //文件名称
                if(file.getName().endsWith(".java")){  //判断是否以.java为结尾
                    fileName = file.getName().substring(0,file.getName().lastIndexOf("."))+".txt";
                    File newfile = new File(file.getParentFile(), fileName);  //新的文件名称
                    file.renameTo(newfile);  //重命名
                }
            }
        }
    }
}

字节流与字符流:

字节流:outputStream以及inputStream

字符流:Writer以及Reader

对资源操作的基本步骤:(文件为例)--严格按照下面步骤

  1. 如果要操作的资源是文件的话,首先需要通过File类对象找到一个要操作的文件路径
  2. 通过字节流或者字符流的子类为字节流或字符流的对象实例化(向上转型)
  3. 执行读写操作
  4. 关闭资源

OutputStream字节输入流

常用的类普通方法:

Modifier and Type Method Description
void close() 关闭此输出流并释放与此流关联的任何系统资源。
void flush() 刷新此输出流并强制写入任何已缓冲的输出字节。
void write(byte[] b) 输出单个字节数据
void write(byte[] b, int off, int len) 输出部分字节数据
abstract void write(int b) 输出一组字节数据

对文件的操作需要其OutputStream下的子类FileOutputStream来实现对象的实例化;

其常用的构造方法是:

Constructor Description
FileOutputStream(File file) 创建一个文件输出流,以写入由指定file对象表示的文件。
FileOutputStream(File file, boolean append) 创建一个文件输出流,以写入由指定file对象表示的文件。如果第二个参数为真,则字节将被写到文件的末尾而不是开头

实例:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;

public class FIleOutputStearm {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt");
        if(!file.exists()){
            file.createNewFile();
        }
        OutputStream outputStearm = new FileOutputStream(file);
        String str = "欢迎来到xbhog的博客";
        outputStearm.write(str.getBytes(StandardCharsets.UTF_8));
        outputStearm.close();
    }
}

文件内容的追加:

    OutputStream stream = new FileOutputStream(file, true);
    String addStr = "-----这是追加的内容------";
    stream.write(addStr.getBytes());
    stream.close();

InputStream字节输入流:

该类的常用方法:

Modifier and Type Method Description
void close() 关闭输出流
abstract int read() 读取单个字节数据,如果现在已经读取到底了,返回-1
int read(byte[] b) 读取一组字节数据,返回的是读取的个数,如果没有数据已经读取到底则返回-1
int read(byte[] b, int off, int len) 读取一组字节数据(只占数组的部分)
byte[] readAllBytes() 读取输入流全部字节数据,JDK 1.9后新增
long transferTo(OutputStream out) 输入流转存到输出流,JDK 1.9之后新增

对文件的操作需要其InputStream下的子类FileInputStream来实现对象的实例化;

读取文件的固定用法:

  1. 创建文件输入流---InputStream input = new FileInputStream(file)
  2. 设置数据的读取缓存区----new byte[1024]
  3. 读取数据,将数据读取到缓存区中并放回读取的字节个数 ----int len = input.read(data)
  4. 字节转换为字符流----new String(data,0,len)
  5. 关闭资源

读取文件内容实例:

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        File file = new File("xbhog.txt"); // 输出文件路径
        if (file.exists()) {    // 文件存在
            InputStream input = new FileInputStream(file);// 文件输入流
            byte data[] = new byte[1024]; // 数据读取缓冲区
            // 读取数据,将数据读取到缓冲区之中,同时返回读取的字节个数
            int len = input.read(data);
            System.out.println("【" + new String(data, 0, len) + "】");// 字节转为字符串
            input.close();    // 关闭输入流

        }
    }
}

读取文件中的全部内容:

byte[] bytes = input.readAllBytes();
System.out.println(new String(bytes));

Writer字符流:

为了简化输出的操作,提供了Writer与Reader字符流;

该类的常用方法:

Modifier and Type Method Description
Writer append(char c) 将指定的字符写入。
Writer append(CharSequence csq) 将指定的字符序列附加到此编写器。
Writer append(CharSequence csq, int start, int end) 将指定字符序列的子序列追加到此编写器
abstract void close() 关闭资源
abstract void flush() 刷新资源流
void write(char[] cbuf) 写入一组字符数组
abstract void write(char[] cbuf, int off, int len) 写入一组字符数组的一部分
void write(int c) 写入一个字符
void write(String str) 写入一个字符串
void write(String str, int off, int len) 写入一个字符串的一部分

在进行文件流的写入时,需要引入Writer下的FileWriter子类;

类的项目结构:

FileWriter常用构造方法:

Constructor Description
FileWriter(File file) 给定File对象,构造一个FileWriter对象。
FileWriter(String fileName, boolean append) 构造一个给定文件名的FileWriter对象,该文件名带有一个布尔值,该布尔值表示是否追加写入的数据。

实例:

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt"); // 输出文件路径
        if(!file.exists()){
            file.createNewFile();
        }
        Writer out = new FileWriter(file) ; // 实例化Writer类对象
        out.write("欢迎来到xbhog");	// 输出字符串
        out.write("\n");
        out.append("Test\n");
        out.append("www.cblog.cn/xbhog") ;// 追加输出内容
        out.close();// 关闭输出流
    }
}

Reader字符输入流:

该类常用的方法:

Modifier and Type Method Description
abstract void close() 关闭资源
int read() 读取单个字符
int read(char[] cbuf) 将字符放入数组
long skip(long n) 跳过字符(几个)
boolean ready() 判断这个流是否已准备好了读取了

实例测试:

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter.txt");// 输出文件路径
        if (file.exists()) {// 文件存在
            Reader in = new FileReader(file);  // 实例化输入流
            char data[] = new char[1024];  // 缓冲区
            //“欢迎没有了”
            in.skip(2);// 跨过2个字符长度
            int len = in.read(data); // 读取数据
            System.out.println(new String(data, 0, len));
            in.close();// 关闭输入流
        }
    }
}

转换流:

转换流 OutputStreamWriter InputStreamReader
继承结构 public class OutputStreamWriterextends Writer {} public class InputStreamReaderextends Reader
构造方法 public OutputStreamWriter(OutputStream out) public InputStreamReader(InputStream in)

实现两者的转换操作:

将字节输入流转换成字符输入流

import java.io.*;
public class ConversionOperations {
    public static void main(String[] args) throws IOException {
        File file = new File("FileWriter1.txt"); 	// 输出文件路径
        OutputStream output = new FileOutputStream(file) ;// 字节流
        Writer out = new OutputStreamWriter(output) ; 	// 字节流转字符流
        out.write("测试两者之间的转换"); // 字符流输出
        out.close();	// 关闭输出流
        output.close(); 	// 关闭输出流
    }
}
文件操作文件操作其实就是一个FIle类;我们学习文件操作就是学习File类中的方法;文件基操:第一部分:学习文件基本操作(先扒源码以及文档)ConstructorDescriptionFile(
文件是一些永久存储及具有特定顺序字节组成一个有序,具有名称集合。与文件有关概念是目录路径和磁盘存储等。提供了一种向后备存储写入字节和从后备存储读取字节方式。后备存储包裹用文件存储或用内存
了解I/O首先简单了解一下javaI/O就相当于一个管道,数据从一个地方传送到另一个地方需要建立一个数据通路,这个通路称做。对应就有输入和输出,注意这里输入输出是相对内存而言。读
一、概述JavaIO支持通过javaio包下类和接口来完成,在javaio包下主要有包括输入、输出两种IO,每种输入输出又可分为字节和字符两大类。从JDK14以后,Java在javanio
JavaI/O实现文件复制1、文件复制原理2、文件遍历算法(1)算法分析(2)算法源码3、文件复制算法(1)算法分析(2)算法源码1、文件复制原理文件类型有很多,从层次上分,有目录(即文件夹)与
重要声明:本文章仅仅代表了作者个人对此观点理解和表述。读者请查阅时持自己意见进行讨论。1、序在Java编程中,I/O操作是必须学会一项技能。无论是文件复制粘贴,还是上传下载,无论是文本
I/O流流:通过不同输入设备(键盘、内存、显示器、网络等)之间数据传输抽象表示为“I/O分类:字节和字符:根据操作数据单位不同,可以分为字节和字符。字节以字节为单位进行数据读写
1流流是一组有序数据序列,I/O提供了一条通道程序,我们使用这个通道可以把源中的字节输送到目的地。我们经常使用I/O与磁盘文件打交道,但是程序源和目的地可以使内存,键盘,鼠标等等。输入输出硬
ystemIO命名空间包含允许在数据流和文件上进行同步,异步及写入类型,下面是关于c文件I/O基本操作讲解,需要朋友可以参考下文件是一些永久存储及具有特定顺序字节组成一个有序,具有名称
本文转自实验楼:https://wwwshiyanloucom/courses/24一linuxI/O介绍Linux下一切皆文件,因此文件操作属于Linux下基本操作。对于用户层来说,所有的操作都是