File类的使用

java.io.File类

代表硬盘上的一个文件或者目录

java.io.File类作用

每个File类的对象表示一个磁盘文件或目录，其对象属性中包含了文件或目录的相关信息，如名称、长度、所含文件个数等，调用它的方法则可以完成对文件或目录的常用管理操作，例如，创建、删除等操作。

Java中文件或者目录的路径表示

Windows中文件或者目录的表示D:\test\1.txt

Java中文件或者目录的表示D:\\test\\1.txt，或者D:/test/1.txt

File类的构造方法

由于File类的每一个对象都表示的是一个具体的目录或者文件，所以File类没有提供无参的构造方法，File类的所有构造方法都需要一个目录或者文件的路径作为参数

File(String pathname)
File(String parent, String child)
File(File parent, String child)

创建File对象

import java.io.File;
public class FileDemo {
    public static void main(String[] args) {
        File f1=new File("D:\\file\\test.txt");
        File f2=new File("D:\\file","test.txt");
        File parent=new File("D:\\file");
        File f3=new File(parent,"test.txt");
    }
}

File类常用方法

boolean createNewFile()创建一个新文件
boolean mkdir() / mkdirs()创建新的目录
boolean delete() 删除文件或者目录
void deleteOnExit() 虚拟机退出时删除文件或者目录
boolean exists() 判断当前文件或者目录是否存在
boolean isFile() 判断File对象代表的是否是一个文件
boolean isDirectory() 判断File对象代表的是否是一个目录
String getPath() 返回当前File对象的字符串路径
String getName()返回当前File对象的文件名或者目录名
String getParent()返回当前File对象的父级目录
String getAbsolutePath()返回当前File对象的绝对路径
String[]list()返回当前File对象包含的子目录以及文件

代码示例

import java.io.File;
import java.io.IOException;
import java.util.Date;
public class GetFileInfos {
    public static void main(String[] args) throws IOException {
        File file=new File("D:\\file\\test.txt");
        System.out.println("文件是否存在： "+file.exists());
        if(!file.exists()){
            System.out.println("创建新文件： "+file.createNewFile());
        }
        System.out.println("文件名： "+file.getName());
        System.out.println("文件路径： "+file.getPath());
        System.out.println("父级目录： "+file.getParent());
        System.out.println("是否可读： "+file.canRead());
        System.out.println("是否可写： "+file.canWrite());
        System.out.println("是否隐藏： "+file.isHidden());
        System.out.println("是否是文件夹： "+file.isDirectory());
        System.out.println("是否是文件： "+file.isFile());
        System.out.println("文件路径是否是绝对路径： "+file.isAbsolute());
        System.out.println("文件最后修改时间： "+new Date(file.lastModified()));
        System.out.println("文件大小： "+file.length()+"bytes");
    }
}

I/O流

流的概念

什么是流

流是一组有序的，有起点和终点的字节集合，是对计算机中数据传输的总称或者抽象。
即数据在两个设备间的传输称为流，流的本质是数据传输(传输数据的载体)。
流序列中的数据可以是没有进行加工的原始数据（二进制字节数据），也可以是经过编码的符合某种格式规定的数据，Java中提供了不同的流类对它们进行处理。

什么是I/O流

I/O流是java中InputStream（输入流）和 OutputStream（输出流）的首字母简称。

输入流（InputStream）

在Java中，程序可以打开一个输入流，输入流的信息源可以位于文件、内存或网络套接字(socket)等地方，信息源的类型可以是包括对象、字符、图像、声音在内的任何类型。一旦打开输入流后，程序就可从输入流串行地读数据。

编辑

输出流（OutputStream）

类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。

编辑

流的分类

按照流传输方向不同

输入流（InputStream）
输出流（OutputStream）

按照处理数据类型的不同

字节流
字符流

按照流的基本功能不同

节点流
过滤流

字节流

字节流的概念

传输的数据单位是字节，也意味着字节流能够处理任何一种文件

字节流的组成

字节输入流 InputStream
字节输出流 OutputStream

编辑

InputStream 是所有输入流流的父类，是一个抽象类

编辑 OutputStream 是所有输出流流的父类，是一个抽象类 编辑

FileInputStream文件输入流类

FileInputStream常用方法

构造方法

FileInputStream(String filename)
FileInputStream(File file)

常用方法

close()
int read()
int read(byte[]b)
int read(byte[] bs, int off, int len)

代码示例

import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("D:\\file\\test.txt");
        //读取一个字节的内容
        int bt=fis.read();
        System.out.println(bt);
        byte[] bts=new byte[1024];
        //读取多个多个字节的内容，放置到数组bts里，返回的是实际读取到的字节数
        int kb=fis.read(bts);
        System.out.println(kb);
    }
}

在test.txt文本文件里写上”哈喽，大家好，我是洛阳的泰山！“类似的内容

import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("D:\\file\\test.txt");
        //读取一个字节的内容
        byte[] buf=new byte[1024];
        while(true){
            int length=fis.read(buf);
            //读取结束时返回-1
            if(length==-1){
                break;
            }
            System.out.println(new String(buf, 0, length));
        };
        //关闭文件输入流
        fis.close();
    }
}

FileOutputStream字节输出流类

FileOutputStream常用方法

常用构造方法

FileOutputStream(String path)
FileOutputStream(File file)
FileOutputStream(String path, boolean append)
FileOutputStream(File file, boolean append)

常用方法

close()
void write(int v)
void write(byte[] bs)
void write(byte[] bs, int off, int len)

代码示例

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
        String text="洛阳泰山，yyds!!!";
        //utf-8字符格式的字节
        byte[] bytes=text.getBytes(StandardCharsets.UTF_8);
        FileOutputStream fos=new FileOutputStream("D:\\file\\test.txt");
        //将内容写入test.txt文本文件
        fos.write(bytes);
        //每次使用完I/O流后，记得关闭，节省计算机资源和安全
        fos.close();
    }
}

字符流

字符流的组成

Reader
Writer

编辑

FileReader

FileReader(String fileName)
close()
int read(char[] cbuf)

FileWriter

FileWriter(String fileName)
close()
write(String value)

InputStreamReader和OutputStreamWriter

特点：

可以把一个字节流转换成一个字符流
在转换时可以执行编码方式

InputStreamReader

InputStreamReader(InputStream is)
InputStreamReader(InputStream is String charSet)
int read(char[] cbuf)

OutputStreamWriter

OutputStreamWriter(OutputStream is)
OutputStreamWriter(OuputtStream is String charSet)
write(String value)

代码示例

import java.io.*;
public class ReaderTest {
    public static void main(String[] args) {
        try {
        InputStream is = new FileInputStream("D:\\file\\test.txt");
        InputStreamReader reader=new InputStreamReader(is);
        char[] cbuf=new char[1024];
        int len=0;
        while ((len=reader.read(cbuf))!=-1){
            for (int i = 0; i < len; i++) {
                char c = cbuf[i];
                System.out.print(c);
            }
            System.out.println();
        }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

过滤流

过滤流在读/写数据的同时可以对数据进行处理，它提供了同步机制，使得某一时刻只有一个线程可以访问一个I/O流，以防止多个线程同时对一个I/O流进行操作所带来的意想不到的结果。类FilterInputStream和FilterOutputStream分别作为所有过滤输入流和输出流的父类。

几种常见的过滤流

BufferedInputStream和BufferedOutputStream 缓冲流，用于提高输入/输出处理的效率。DataInputStream和DataOutputStream不仅能读/写数据流，而且能读/写各种的java语言的基本类型，如：boolean，int，float等。
LineNumberInputStream 除了提供对输入处理的支持外，LineNumberInputStream可以记录当前的行号。
PushbackInputStream提供了一个方法可以把刚读过的字节退回到输入流中，以便重新再读一遍。
PrintStream打印流的作用是把Java语言的内构类型以其字符表示形式送到相应的输出流

过滤流的开发步骤

创建节点流
基于节点流创建过滤流
读/写数据
关闭外层流

代码示例

import java.io.*;
public class DataStreamTest {
    public static void main(String[] args) throws IOException {
        //文件地址
        String filePath="D:\\file\\test.txt";
        //创建文件输出流
        FileOutputStream fos=new FileOutputStream(filePath);
        //创建数据输出流
        DataOutputStream dos=new DataOutputStream(fos);
        //写入圆周率
        dos.writeDouble(3.1415);
        //关闭数据输出流
        dos.close();
        //关闭文件输出流
        fos.close();
        //创建文件输入流
        FileInputStream fis=new FileInputStream(filePath);
        //创建数据输入流
        DataInputStream dis=new DataInputStream(fis);
        //读取double类型的数据
        double PI=dis.readDouble();
        //关闭数据输入流
        dis.close();
        //关闭文件输入流
        fis.close();
        //打印数据
        System.out.println(PI);
    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class BufferedStreamTest {
    public static void main(String[] args) throws IOException {
        String data="洛阳泰山，牛逼666!!!";
        byte[] bts=data.getBytes(StandardCharsets.UTF_8);
        //创建文件输出流
        FileOutputStream fos=new FileOutputStream("D:\\file\\test.txt");
        //创建缓冲输出流
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //写入文本数据
        bos.write(bts);
        bos.close();
        fos.close();
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectStreamTest {
   static class Student implements Serializable {
        String name;
        int age;
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    public static void main(String[] args) throws IOException {
        Student stu=new Student("泰山",28);
        //创建文件输出流
        FileOutputStream fos=new FileOutputStream("D:\\file\\test.txt");
        //创建对象输出流
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //写入对象
        oos.writeObject(stu);
        oos.close();
        fos.close();
    }
}

BufferedReader

字符过滤流
提供了缓冲功能
可以一行一行的读取内容
public String readLine()

完整的字符输入流的开发步骤

创建节点流
桥转换为字符流
在字符流的基础上封装过滤流
读/写数据
关闭外层流

import java.io.*;
public class PrintStreamTest {
    public static void main(String[] args) throws IOException {
        //创建文件输出流（true 表示数据可以拼接）
        OutputStream os=new FileOutputStream("D:\\file\\test.txt",true);
        //字创建符打印流
        PrintWriter pw=new PrintWriter(os);
        pw.print("hallo,洛阳泰山");
        //刷新
        pw.flush();
        //关闭
        os.close();
    }
}

PrintWriter 介绍

具有自动行刷新的缓冲字符输出流，特点是可以按行写出字符串，并且可以自动行刷新。

java.io.BufferedWriter是缓冲字符输出流，内部有缓冲区可以进行块写操作提供效率，

而PrintWriter就是通过连接它实现的缓冲功能（PW的很多构造方法内部自动连接它）。

PW支持两个直接对文件写操作的构造方法：

PrintWriter(File f)传文件名
PrintWriter(String s)传路径

以上两种方法都支持一个重载，就是再传入一个参数

PrintWriter 特性

允许我们制定写出字符时的字符集。
PrintWriter给人一种可以直接对文件进行操作的假象
PW是一个高级流
实际上PW包装了字节流、字符流和字符缓冲流。
PW负责自动行刷新
bw负责提高效率
osw负责读字符
fos负责写字节
最后PW能够按行很快地把一个字符串变成字节写在文件中

Java 基础入门 | 第十四章 File以及I/O流

File类的使用

I/O流

流的概念

流的分类

字节流

字符流

过滤流

热门文章

最新文章

相关课程

相关电子书

相关实验场景