File类
1.概述:
java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。
java把电脑中的文件和文件夹(就是目录)封装为了一个File类,可以使用File类对文件和文件夹进行操作。
可以使用File类中的方法,一般会包括:
创建一个文件/文件夹
删除一个文件/文件夹
判断文件/文件夹是否存在
对文件夹进行遍历
获取文件的大小
file(文件)、directory(文件夹)、path(路径)。
2.绝对路径和相对路径的对比:
- 绝对路径是一个完整的路径。以盘符(比如C:,D:)开始的路径,例如c:\\a.txt,C:\\Users\jupy\\Programs\\java\\code_0\\test.txt,D:\\demo\\b.txt
- 相对路径是一个简化的路径,相对于当前项目的根目录。如果使用当前项目的根目录,路径可以简化书写,例如C:\\Users\jupy\\Programs\\java\\code_0\\test.txt可以简化为code_0\\test.txt。其中红色部分是当前项目的根目录。
注意:(1)路径是不区分大小写。(2)路径中的文件名称分隔符,在Windows中使用反斜杠,反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠;在linux种使用单个正斜杠,不需要转义。
3.File类的静态变量:
static String pathSeparator 与系统有关的路径分隔符,windows为分号,Linux为冒号。
static char pathSeparatorChar 与系统有关的路径分隔符。和上面是一样的
static String separator 与系统有关的默认名称分隔符(文件名称分隔符),Windows为反斜杠。linux为正斜杠。
static char separatorChar 与系统有关的默认名称分隔符。和上面是一样的。
注意:路径不能写死了,不能写死用windows格式或者linux格式,当代码放在不同系统下的时候时会报错的。
C:\develop\a\a.txt Windows系统
C:/develop/a/a.txt Linux系统
“C:”+File.separator+"develop"+File.separator+"a"+File.separator+"a.txt" 自动选择路径格式
import java.io.File;
public class FileTest {
public static void main(String[] args) {
String pathSeparator = File.pathSeparator; // 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。
char pathSeparatorChar = File.pathSeparatorChar; // 与系统有关的路径分隔符,被表示为一个字符。
String separator = File.separator; // 与系统有关的默认名称分隔符(windows是反斜杠\),为了方便,它被表示为一个字符串。
char separatorChar = File.separatorChar; // 和上面一样,但是是字符。
System.out.println("本系统的路径分隔符String:"+pathSeparator+
" 本系统的路径分隔符char:"+pathSeparatorChar+
" 本系统的默认名称分隔符String:"+separator+
" 本系统的默认名称分隔符char:"+separatorChar);
// 本系统的路径分隔符String:; 本系统的路径分隔符char:; 本系统的默认名称分隔符String:\ 本系统的默认名称分隔符char:\
}
}
4.构造方法(3种)创建新的File实例,该实例要么是文件,要么是文件夹。
- public File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
注意:(1)路径(pathname)可以是以文件结尾,也可是文件夹结尾。
(2)路径可以是相对路径,也可以是绝对路径。
(3)路径可以是存在,也可以是不存在。因为创建File对象只是把字符串路径封装为File对象,不考虑路径的真假情况。 - public File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。
好处:父路径和子路径可以单独写,使用起来非常灵活,父路径和子路径都可以变化。 - public File(File parent, String child) :从父抽象路径名和子路径名字符串组合创建新的 File实例。
好处:(1)父路径和子路径可以单独写,使用起来非常灵活,父路径和子路径都可以变化。
(2)父路径是File类型,可以使用File的方法对路径进行一些操作,再使用路径创建对象。
5.常用方法(大致分为4类)
- 获取功能的方法
- 判断功能的方法
- 创建删除功能的方法
- 目录遍历功能的方法
5.1.获取功能的方法
- public String getAbsolutePath() :返回文件/文件夹的绝对路径。
- public String getPath() :返回文件/文件夹的构造路径。
- public String getName() :返回由此File表示的文件/文件夹的名称。
- public long length() :返回由此File表示的文件的长度(仅指文件的大小)。
注意:文件夹是没有大小的概念,不管里面是否存在文件,都是返回0.
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File f = new File("C:\\Users\\jupy\\Documents\\Scripts\\bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath()); // 文件绝对路径:C:\Users\jupy\Documents\Scripts\bbb.java
System.out.println("文件构造路径:"+f.getPath()); // 文件构造路径:C:\Users\jupy\Documents\Scripts\bbb.java
System.out.println("文件名称:"+f.getName()); // 文件名称:bbb.java
System.out.println("文件长度:"+f.length()+"字节"); // 文件长度:0字节
File f2 = new File("Scripts\\bbb");
System.out.println("目录绝对路径:"+f2.getAbsolutePath()); // 目录绝对路径:C:\Users\jupy\IdeaProjects\basic_code\Scripts\bbb
System.out.println("目录构造路径:"+f2.getPath()); // 目录构造路径:Scripts\bbb
System.out.println("目录名称:"+f2.getName()); // 目录名称:bbb
System.out.println("目录长度:"+f2.length()); // 目录长度:0
}
}
5.2.判断功能的方法
- public boolean exists() :此File表示的文件/文件夹是否实际存在。用于判断构造方法中的路径是否存在,存在:true;不存在:false。
- public boolean isDirectory() :此File表示的是否为文件夹。用于判断构造方法中给定的路径是否以文件夹结尾
- public boolean isFile() :此File表示的是否为文件。 用于判断构造方法中的路径是否以文件结尾。
注意:
(1)电脑的硬盘中只有文件/文件夹,两个方法(isFile和isDirectory)是互斥的。
(2)这两个方法(isFile和isDirectory)使用前提,路径必须是存在的,否则都返回false。
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File f1 = new File("C:\\Users\\jupy\\Documents\\Scripts\\test.txt"); // 文件
File f2 = new File("C:\\Users\\jupy\\Documents\\Scripts"); // 文件夹
File f3 = new File("D:\\Users\\jupy\\Documents\\Scripts"); // 不存在的文件夹
// 判断是否存在
System.out.println("C:\\Users\\jupy\\Documents\\Scripts\\test.txt 是否存在:"+f1.exists()); // C:\Users\jupy\Documents\Scripts\test.txt 是否存在:true
System.out.println("C:\\Users\\jupy\\Documents\\Scripts 是否存在:"+f2.exists()); // C:\Users\jupy\Documents\Scripts 是否存在:true
// 判断是文件还是目录
System.out.println("C:\\Users\\jupy\\Documents\\Scripts 文件?:"+f2.isFile()); // C:\Users\jupy\Documents\Scripts 文件?:false
System.out.println("C:\\Users\\jupy\\Documents\\Scripts 目录?:"+f2.isDirectory()); // C:\Users\jupy\Documents\Scripts 目录?:true
System.out.println("D:\\Users\\jupy\\Documents\\Scripts 目录?:"+f3.isDirectory()); // D:\Users\jupy\Documents\Scripts 目录?:false
}
}
5.3. 创建删除功能的方法
- public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。创建的是文件!
创建文件的路径和文件名称在构造方法中给出(构造方法的参数)。如果文件不存在,就创建文件返回true;如果文件存在,则不会创建,返回false。
注意:(1)此方法只能创建文件,不能创建文件夹。(2)创建文件的路径必须存在,否则会抛出IOException异常,我们调用这个方法,就必须处理这个异常,要么throw,要么try-catch。 - public boolean delete() :删除由此File表示的文件/目录。
注意:delete方法直接在硬盘删除文件/文件夹,不走回收站,删除要谨慎! - public boolean mkdir() :创建由此File表示的目录。创建的是文件夹!只能创建单级空文件夹。
创建文件夹的路径和文件夹名称在构造方法中给出(构造方法的参数)。如果文件夹不存在,就创建文件返回true;如果文件夹存在,则不会创建,返回false。
注意:(1)此方法只能创建文件夹,不能创建文件。(2)如果要创建多级文件夹,不会发生任何异常,一律返回false。 - public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。创建多层文件夹,也可以创建单级空文件夹,即使父类文件夹不存在,也会一并创建。
import java.io.File;
import java.io.IOException;
public class FileTest {
public static void main(String[] args) throws IOException {
// 文件的创建
File f = new File("aaa.txt");
System.out.println(f.getAbsoluteFile());
System.out.println("文件aaa.txt是否存在:"+f.exists()); // 文件aaa.txt是否存在:false
// 注意一定要处理异常,要么throw,要么try-catch。这里选择前者。
System.out.println("文件aaa.txt是否创建:"+f.createNewFile()); // 文件aaa.txt是否创建:true
System.out.println("文件aaa.txt是否存在:"+f.exists()); // 文件aaa.txt是否存在:true
// 目录的创建
File f2= new File("newDir"); // 单级空目录
System.out.println("文件夹newDir是否存在:"+f2.exists());// 文件夹newDir是否存在:false
System.out.println("文件夹newDir是否创建:"+f2.mkdir()); // 文件夹newDir是否创建:true
System.out.println("文件夹newDir是否存在:"+f2.exists());// 文件夹newDir是否存在:true
// 创建多级目录
File f3= new File("newDira\\newDirb"); // 多级目录,其中父目录不存在
System.out.println("使用mkdir,创建多级文件夹是否创建:"+f3.mkdir());// 使用mkdir,创建多级文件夹是否创建:false
System.out.println("使用mkdirs,创建多级文件夹是否创建:"+f3.mkdirs());// 使用mkdirs,创建多级文件夹是否创建:true
// 文件的删除
System.out.println("单级文件aaa.txt是否删除:"+f.delete());// 单级文件aaa.txt是否删除:true
// 目录的删除
System.out.println("单级文件夹newDir是否删除:"+f2.delete());// 单级文件夹newDir是否删除:true
System.out.println("多级文件夹newDira\\newDirb是否删除:"+f3.delete());// 多级文件夹newDira\newDirb是否删除:true
}
}
5.4.目录(文件夹)遍历的方法
- public String[] list() :返回一个String数组,表示该File目录中的所有子文件或目录。
遍历构造方法中给出的目录,会获取目录中所文件/文件夹的名称,把获取到的多个名称存储到一个String类型数组中。 - public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。
遍历构造方法中给出的目录,会获取目录中所有的文件/文件夹,把文件/文件夹封装为File对象存储到File数组中
注意:
(1)list方法和listFiles方法遍历的是构造方法中给出的目录。
(2)如果构造方法中给出的目录路径不存在,会抛出NullPointerException空指针异常;如果构造方法中给出的路径不是一个目录,也会抛出空指针异常。
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File dir = new File("C:\\Users\\jupy\\Documents\\电子版书籍");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取dir目录下的文件以及文件夹对象,只要拿到了文件对象,那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
6.案例:
1.文件搜索。
题目要求:搜索D:aaa目录中的.java文件。
分析:(1)目录搜索,无法判断多少级目录,所以使用递归,遍历所有目录。(2) 遍历目录时,获取的子文件,通过文件名称,判断是否符合条件。
import java.io.File;
public class FileTest {
public static void main(String[] args) {
File dir = new File("C:\\Users\\jupy\\Documents\\电子版书籍");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
//获取dir目录下的文件以及文件夹对象,只要拿到了文件对象,那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
2.文件过滤器优化。
题目要求:java.io.FileFilter是一个接口,是File的过滤器。该接口的对象可以传递给 File类的listFiles(FileFilter)作为参数,接口中只有一个方法。boolean accept(File pathname):测试pathname是否应该包含在当前File目录中,符合则返回true。
分析:(1)接口作为参数,需要传递子类对象,重写其中的方法。可以选择匿名内部类方式。(2)accept方法,参数为File,表示当前File夏所有的子文件和子目录。保留住则返回true,过滤掉则返回false。保留的规则:要么是.java文件,要么是目录用于继续遍历。(3)通过过滤的作用,listFiles(FileFilter)返回的数组元素中,子对象都是符合条件的,可以直接打印。
import java.io.File;
import java.io.FileFilter;
public class FileTest {
public static void main(String[] args) {
File dir = new File("D:\\aaa");
printDir2(dir);
}
public static void printDir2(File dir) {
// 匿名内部类方式,创建过滤器子类对象
File[] files = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".java")||pathname.isDirectory();
}
});
// 循环打印
for (File file : files) {
if (file.isFile()) {
System.out.println("文件名:" + file.getAbsolutePath());
} else {
printDir2(file);
}
}
}
}
优化:FileFilter 是只有一个方法的接口,因此可以用lambda表达式简写。
public static void printDir3(File dir) {
// lambda的改写
File[] files = dir.listFiles(f ->{return f.getName().endsWith(".java") || f.isDirectory();});
// 循环打印
for (File file : files) {
if (file.isFile()) {
System.out.println("文件名:" + file.getAbsolutePath());
} else {
printDir3(file);
}
}
}
IO
概述
把数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input 和输出output ,即流向内存是输入流,流出内存的输出流。
Java中I/O操作主要是指使用java.io 包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。
IO的分类
根据数据的流向分为:输入流和输出流。
- 输入流 :把数据从其他设备上读取到内存中的流。
- 输出流 :把数据从内存 中写出到其他设备上的流。
流的数据的类型分为:字节流和字符流。1个字符=2个字节,1个字节=8个二进制。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
IO的流向说明图解
顶级父类们
字节流(OutputStream和InputStream)
一切皆为字节:一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都是一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
1.字节输出流(OutputStream)
java.io.OutputStream 抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。以下是一些字节输出流的基本共性功能方法。
- public void close() :关闭此输出流并释放与此流相关联的任何系统资源。close方法,当完成流的操作时,必须调用此方法,释放系统资源。
- public void flush() :刷新此输出流并强制写出任何缓冲的输出字节。
- public void write(byte[] b) :将 b.length字节从指定的字节数组写入此输出流。
- public void write(byte[] b, int off, int len) :从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。
- public abstract void write(int b) :将指定的字节输出流。
字节输出流的子类FileOutputStream类
FileOutputStream是OutputStream抽象类的子类。java.io.FileOutputStream extends OutputStream 类是文件字节输出流,用于将内存中的数据写入到硬盘的文件中。
1.1.构造方法
- public FileOutputStream(File file) :创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name) : 创建文件输出流以指定的名称写入文件。
构造方法的参数:表示写入数据的目的地。String name:目的地的一个文件路径。File file:目的地是一个文件。
构造方法的作用:
(1)创建一个FileOutputStream对象。
(2)会根据构造方法中传递的文件/文件路径,创建一个空的文件。
(3)会把FileOutputStream对象指向创建好的文件
注意:当创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
1.2.从内存写入硬盘,写出字节数据
写入数据的原理(内存-->硬盘):java程序 ---> JVM(虚拟机)----> OS(操作系统)-----> OS调用写数据的方法----> 把数据写入文件中。
字节输出流的使用步骤(重点):
(1)创建一个FileOutputStream对象,构造方法中传递写入数据的目的地。
(2)调用FileOutputStream对象中的write方法,将数据写入到文件中。
(3)调用OutputStream对象中的close方法释放资源(流的使用会占用一定的内存,使用完毕要把内存释放,提高程序的效率)
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
public static void main(String[] args) throws IOException {
// 1. 创建一个FileOutputStream对象,构造方法中传递写入数据的目的地。相对路径,项目根目录下.
FileOutputStream fos1 = new FileOutputStream("a.txt");
FileOutputStream fos2 = new FileOutputStream("b.txt"); // 创建一个空文件
// 2.调用FileOutputStream对象中的write方法,将数据写入到文件中。
fos1.write(97);
// 3.释放资源
fos1.close();
File file1 = new File("a.txt");
File file2 = new File("b.txt");
File file3 = new File("c.txt");
file3.createNewFile(); // 使用File中的方法创建一个空文件
System.out.println(file1.length()); // 1 表示文件的大小现在是1字节。
System.out.println(file2.length()); // 0 表示文件的大小现在是0字节,是空文件,什么东西都没有。
System.out.println(file3.length()); // 0 表示文件的大小现在是0字节,什么东西都没有。
}
}
当打开a.txt,里面并不是数字97而是字母a,文件存储原理如下:
上面已经可以直接使用write方法写入一个字节,但是需要一次性写入多个字节,方法如下:
(1)public void write(byte[] b):将b.length个字节写入此输出流。
(2)public void write(byte[] b,int off ,int len):从指定的字节数组,从偏移量off开始的len个字节写入此输出流。
字符数组可以通过String类中的方法,把字符串转换为字节数组。String类中有一个getBytes方法:byte[] getBytes()
写入多字节(字节数组)注意:
如果碰到的字节是正数(0-127),那么显示的时候会查询ASIIC表。如果碰到的字节是负数,那该字节会和下一个字节组合成一个中文显示,查询系统默认码表(中文系统GBK)。
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class FileOutputStreamTest {
public static void main(String[] args) throws IOException {
// 1. 创建一个FileOutputStream对象,构造方法中传递写入数据的目的地。相对路径,项目根目录下.
FileOutputStream fos = new FileOutputStream("a.txt");
// 向文件中写入100
fos.write(49); // 对应的ASIIC码是1
fos.write(48); // 对应的ASIIC码是0
fos.write(48); // 对应的ASIIC码是0
// 等效于下面的一次性写入,继续在后面写入100
byte[] bytes = {49,48,48};
fos.write(bytes);
byte[] bytes1 = {65,66,67,68,69}; // ABCD
fos.write(bytes1);
// 因为第一个是负数,所以第一个和第二个会组合在一起然后在GBK表中查找对应的中文
fos.write(50); // 2
byte[] bytes2 = {-65,66,67,68,69}; // GBk格式: 緽CDE。 UTF-8格式:�BCDE ISO-8859-1格式:¿BCDE
fos.write(bytes2);
fos.write(51); //3
byte[] bytes3 = {-65,66,-67,68,69}; // GBk格式: 緽紻E。 UTF-8格式:�B�DE ISO-8859-1格式:¿B½DE
fos.write(bytes3);
fos.write(54); // 6
byte[] bytes6 = {65,66,-67,68,-69}; // GBk格式: AB紻�。 UTF-8格式:AB�D� ISO-8859-1格式:AB½D»
fos.write(bytes6);
fos.write(56); // 8
byte[] bytes8 = {-65,-66,-67,68,69}; //GBk格式: 烤紻E。 UTF-8格式:���DE ISO-8859-1格式:¿¾½DE
fos.write(bytes8);
fos.write(52); // 4
byte[] bytes4 = {-65,66,-67,68,-69}; //GBk格式: 緽紻�。 UTF-8格式:�B�D� ISO-8859-1格式:¿B½D»
fos.write(bytes4);
fos.write(55); // 7
byte[] bytes7 = "你好".getBytes(); //GBk格式: 浣犲ソ。 UTF-8格式:你好 ISO-8859-1格式:ä½ å¥½
System.out.println(Arrays.toString(bytes7)); // [-28, -67, -96, -27, -91, -67] 因为java是utf-8编码的,3个字节为一个中文
fos.write(bytes7);
fos.write(57); // 9
byte[] bytes9 = {-28, -67, -96, -27, -91, -67}; //GBk格式: 緽紻�。 UTF-8格式:�B�D� ISO-8859-1格式:¿B½D»
fos.write(bytes9);
fos.close(); // 写入的内容为:100100ABCDE2緽CDE3緽紻E6AB紻�8烤紻E4緽紻�
}
}
(2)写出字节数组
(3)写出指定长度字节数组
1.3.数据追加续写
每次程序运行,创建输出流对象,都会清空目标文件中的数据。想要保留目标文件中数据,还能继续添加新数据则需要在构造方法的参数中再传入一个Boolean类型的值。
- public FileOutputStream(File file, boolean append) : 创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name, boolean append) : 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值, true 表示追加数据, false 表示清空原有数据。
1.4写出换行
2.字节输入流(InputStream)
java.io.InputStream 抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。以下是一些字节输入流的基本共性功能方法。
- public void close() :关闭此输入流并释放与此流相关联的任何系统资源。close方法,当完成流的操作时,必须调用此方法,释放系统资源。
- public abstract int read() : 从输入流读取数据的下一个字节。
- public int read(byte[] b) : 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
字节输入流的子类FileInputStream类
java.io.FileInputStream 类是文件输入流,从文件中读取字节。
2.1构造方法
- FileInputStream(File file) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
- FileInputStream(String name) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
当创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException 。
2.2读取字节数据
(1)读取字节
(2)读取字节数组
3.字节流案例
字符流
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
1.字符输入流(Reader)
java.io.Reader 抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。以下是一些字符输入流的基本共性功能方法。
- public void close() :关闭此流并释放与此流相关联的任何系统资源。
- public int read() : 从输入流读取一个字符。
- public int read(char[] cbuf) : 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
字符输入流的子类FileReader类
java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
备注:(1)字符编码:字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。idea中UTF-8。
(2)字节缓冲区:一个字节数组,用来临时存储字节数据。
1.1.构造方法
- FileReader(File file) : 创建一个新的 FileReader ,给定要读取的File对象。
- FileReader(String fileName) : 创建一个新的 FileReader ,给定要读取的文件的名称。
当创建一个流对象时,必须传入一个文件路径。类似于FileInputStream 。
1.2.读取字符数据
(1)读取字符
(2)读取字符数组
2.字符输出流(Writer)
java.io.Writer 抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的地。以下是一些字节输出流的基本共性功能方法。
- void write(int c) :写入单个字符。
- void write(char[] cbuf): 写入字符数组。
- abstract void write(char[] cbuf, int off, int len): 写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
- void write(String str): 写入字符串。
- void write(String str, int off, int len): 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
- void flush(): 刷新该流的缓冲。
- void close() :关闭此流,但要先刷新它。
字符输出流的子类FileWriter类
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
2.1.构造方法
- FileWriter(File file) : 创建一个新的 FileWriter,给定要读取的File对象。
- FileWriter(String fileName) : 创建一个新的 FileWriter,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
2.2.基本写出数据
(1)写出字符
(2)写出字符数组
(3)写出字符串
(4)续写和换行
2.3.关闭和刷新
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush 方法了。
- flush:刷新缓冲区,流对象可以继续使用。
- close:先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。