File类
- 概述
1.File在java.io.File包下是文件和目录路径名的抽象表示。
2.主要用于文件和目录的创键、查找、删除操作。 - 构造方法
1.代码:
public class test {
public static void main(String[] args) {
/**
* 第一种:通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
*/
//路径
String g="G:\\test\\1.txt";
File file = new File(g);
/**
* 第二种:从父路径名字符串和子路径名字符串创建新的 File实例。
*/
//通过父路径和子路径字符串
String fu="G:\\test";
String zi="1.txt";
File file1 = new File(fu, zi);
/**
* 第三种:从父抽象路径名和子路径名字符串创建新的 File实例
*/
// 通过父级File对象和子路径字符串
File file2 = new File("G:\\test");
String zi1="1.txt";
File file3 = new File(file2, zi1);
}
}
- File常用的方法
1.代码:
public class test1 {
public static void main(String[] args) {
File file = new File("G:/aaa/1.txt");
//返回此File的绝对路径名 getAbsolutePath()
System.out.println(file.getAbsolutePath());
//将此File转换为路径名 getPath()
System.out.println(file.getPath());
//返回由此File表示的文件或目录的名称 getName()
System.out.println(file.getName());
//返回由此File表示的文件的长度 length()
System.out.println(file.length());
结果:
G:\aaa\1.txt
G:\aaa\1.txt
1.txt
12
- 什么是绝对路径和相对路径
绝对路径 : 从盘符开始的路径,就是一个完整的路径。
相对路径 : 相当于项目目录的路径,这是一个便捷的路径,开发中经常 使用
演示:
public class test2 {
public static void main(String[] args) {
//绝对路径
File file = new File("G:/aaa/1.txt");
System.out.println(file.getAbsolutePath());
//相对路径
File file1 = new File("1.txt");
System.out.println(file1.getAbsolutePath());
}
}
- 判断功能方法
案例:
public class test3 {
public static void main(String[] args) {
File file = new File("G:/aaa/1.txt");
//此File表示的文件或目录是否实际存在 exists()
System.out.println(file.exists());
/**
* 判断是文件还是目录
*/
//是不是文件 isFile()
System.out.println(file.isFile());
//是不是目录 isDirectory()
System.out.println(file.isDirectory());
}
}
结果:
true
true
false
- 删除功能的方法
案例:
public class test4 {
public static void main(String[] args) throws IOException {
File file = new File("2.txt");
/**
* createNewFile()
* 当具有该名称的文件尚不存在时,创建一个新的空文件
*/
System.out.println(file.exists());//是否存在,不存在创建 false
System.out.println(file.createNewFile());//创建 true
System.out.println(file.exists());//是否存在 true
File test = new File("test");
/**
* mkdir()
* 目录的创建
*/
System.out.println(test.exists());//目录是否存在 false
System.out.println(test.mkdir());//创建 true
System.out.println(test.exists());//目录是否存在 true
/**
* mkdirs()
* 创建多级目录
*/
File f1 = new File("AAA\\BBB");
System.out.println(f1.mkdirs()); //true
System.out.println(f1.mkdirs());//只能创建一次 false
/**
* 删除 delete()
* 文件目录都一样
*/
System.out.println(file.delete());//true
System.out.println(test.delete());//true
System.out.println(f1.delete());//true
}
}
delete方法,如果此File表示目录,则目录必须为空才能删除。
- 目录的遍历
案例:
public class test5 {
public static void main(String[] args) {
File file = new File("G:/aaa");
/**
* list()
* 返回一个String数组,表示该File目录中的所有子文件或目录
*/
//获取当前目录下的文件以及文件夹的名
String[] list = file.list();
for (String s : list) {
System.out.println(s);
}
System.out.println("----------------------------------");
/**
* listFiles()
* 返回一个File数组,表示该File目录中的所有的子文件或目
*/
//获取当前目录下的文件以及文件夹对象,只要拿到了文件对象,那么就可以获取更多信息
File[] files = file.listFiles();
for (File file1 : files) {
System.out.println(file1);
}
}
}
结果:
1.png
1.txt
2.png
----------------------------------
G:\aaa\1.png
G:\aaa\1.txt
G:\aaa\2.png
调用listFiles方法的File对象,表示的必须是实际存在的目录,否则返回null,无法进行遍历。
递归打印多级目录(笔试题)下面超链接
递归打印多级目录
IO流
IO概述???
当你电脑上 插入一个U盘,可以把一个文件,拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢?
键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input 和输出 output ,即流向内存是输入流(读取数据),流出内存的输出流(写数据)。
IO分类
- 输入流:把数据从其他设备上读取到内存中的流
- 输出流:把数据从内存中写出道其他设备上的流
数据分为:字节和字符
- 字节流:以字节为单位,读写数据的流
- 字符流:义字符为单位,读写数据的流
IO大家族
输入流 | 输出流 | |
---|---|---|
字节流 | 字节输入流 InputStream | 字节输出流 OutputStream |
字符流 | 字符输入流 Reader | 字符输出流 Writer |
字节流
字节输出流
什么是字节???
电脑储存的图片、视频、文件都是以二进制数字形式保存的,都是一个个的字节,传输也是如此。字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传 输的始终为二进制数据。
OutputStream
java.io.OutputStream是所有字节输出流的超类,定义一些字节输出流的基本公用方法
- public void 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) :将指定的字节输出流
在完成操作时候必须调用close()方法释放资源
FileOutputStream类
java.io.FileOutputStream 类是文件输出流,用于将数据写出到文件。
方法:
- public FileOutputStream(File file) :创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name) : 创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件, 会清空这个文件的数据。
案例:
public class test0 {
public static void main(String[] args) throws FileNotFoundException {
//使用File创建流对象 第一种
File file = new File("1.txt");
FileOutputStream fileOutputStream = new FileOutputStream(file);
//使用文件名创建流对象 第二种
FileOutputStream fileOutputStream1 = new FileOutputStream("1.txt");
}
}
写出字节数据
1.write(int b)方法,每次可以写入一个字节
public class test1 {
public static void main(String[] args) throws IOException {
//创建输出流对象
FileOutputStream stream = new FileOutputStream("1.txt");
stream.write(11);// 写出第1个字节
stream.write(22);// 写出第2个字节
//关闭资源
stream.close();
}
}
虽然参数为int类型四个字节,但是只会保留一个字节的信息写出
- write(byte[] b) ,每次可以写出数组中的数据。
public class test2 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("1.txt");
//使用数组方式
byte[] bytes = "博主真帅".getBytes();
fileOutputStream.write(bytes);
fileOutputStream.close();
}
}
- write(byte[] b, int off, int len) 写出指定长度字节数组
public class test3 {
public static void main(String[] args) throws IOException {
FileOutputStream stream = new FileOutputStream("1.txt");
byte[] bytes = "abcdefg".getBytes();
//写出从索引2开始,3个字节。索引2是c,3个字节,也就是cde
stream.write(bytes,3,2);
stream.close();
}
}
数据追加续写
经过以上的演示,每次程序运行,创建输出流对象,都会清空目标文件中的数据。如何保留目标文件中数据,还能继 续添加新数据呢?
- public FileOutputStream(File file, boolean append) : 创建文件输出流以写入由指定的 File对象表示 的文件。
- public FileOutputStream(String name, boolean append) : 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值, true 表示追加数据, false 表示清空原有数据。这样 创建的输出流对象,就可以指定是否追加续写了。
案例:
public class test4 {
public static void main(String[] args) throws IOException {
FileOutputStream stream= new FileOutputStream("1.txt",true);
byte[] bytes = "BBB".getBytes();
stream.write(bytes);
stream.close();
}
}
写出换行
Windows系统里,换行符号是 \r\n 本人是Win10
public class test5 {
public static void main(String[] args) throws IOException {
FileOutputStream stream = new FileOutputStream("G:\\aaa\\1.txt");
byte [] b={1,2,3,4,5,6};
//遍历数组
for (int i = 0; i < b.length; i++) {
// 写出一个字节
stream.write(b[i]);
// 写出一个换行, 换行符号转成数组写出
stream.write("\r\n".getBytes());
}
stream.close();
/**
* 1
* 2
* 3
* 4
* 5
* 6
*/
}
}
- 回车符 \r 和换行符 \n :
1.回车符:回到一行的开头(return)。
2.换行符:下一行(newline)。 - 系统中的换行:
1.Windows系统里,每行结尾是 回车+换行 ,即 \r\n ;
2.Unix系统里,每行结尾只有 换行 ,即 \n ;
3.Mac系统里,每行结尾是 回车 ,即 \r 。从 Mac OS X开始与Linux统一。
字节输入流
InputStream
java.io.InputStream是所有字节输入流的超类,定义一些字节输入流的基本公用方法
- public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
- public abstract int read() : 从输入流读取数据的下一个字节
- public int read(byte[] b) : 从输入流中读取一些字节数,并将它们存储到字节数组 b中
FileInputStream类
方法:
java.io.FileInputStream 类是文件输入流,从文件中读取字节
- FileInputStream(File file) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系 统中的 File对象 file命名。
- FileInputStream(String name) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件 系统中的路径名 name命名。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出 FileNotFoundException
案例:
public class test0 {
public static void main(String[] args) throws FileNotFoundException {
//使用File对象创建
File file = new File("G:\\aaa\\1.txt");
FileInputStream stream1 = new FileInputStream(file);
//使用文件名创建
FileInputStream stream2 = new FileInputStream("G:\\aaa\\1.txt");
}
}
读取字节数据
- read ()方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1 。
public class test1 {
public static void main(String[] args) throws IOException {
FileInputStream s = new FileInputStream("G:\\aaa\\1.txt");
//1.txt 里数据是abcd
//读取数据返回一个字节
int read = s.read();
System.out.println((char) read);//第一个 a
read = s.read();
System.out.println((char) read);//第二个 b
read = s.read();
System.out.println((char) read);//第三个 c
read = s.read();
System.out.println( (char) read);//第四个 d
read = s.read();
System.out.println(read);// -1
s.close();
}
}
循环读取:
public class test2 {
public static void main(String[] args) throws IOException {
FileInputStream s = new FileInputStream("G:\\aaa\\1.txt");
int a;
while ((a=s.read())!=-1){
System.out.println((char) a);
}
s.close();
/**
* 输出
* a
* b
* c
* d
*/
}
}
使用字节数组读取
read(byte[] b) ,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取 到末尾时,返回-1
public class test3 {
public static void main(String[] args) throws IOException {
FileInputStream s = new FileInputStream("G:\\aaa\\1.txt");
// 定义变量,作为有效个数
int len;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];//每次读取2个
while ((len=s.read(b))!=-1){
System.out.println(new String(b));
}
s.close();
/**
* 输出
* ab
* cd
*/
}
}
使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。
图片复制
代码:
public class test4 {
public static void main(String[] args) throws IOException {
//创建流对象 输入流读取图片
FileInputStream inputStream= new FileInputStream("G:\\aaa\\1.png");
//创建流对象 输出写入取图片
FileOutputStream outputStream = new FileOutputStream("2.png");
byte[] b = new byte[1024];
int len;
while ((len=inputStream.read(b))!=-1){
outputStream.write(b,0,len);
}
inputStream.close();
outputStream.close();
}
}
字符流
字符输入流Reader
Reader是读取字符流所有类的超类,定义了字符输入流的公用基本方法。
- void close():关闭流释放资源;
- int read():从输入流读取一个字符;
- int read(char[] cbuf):从输入流中读取一些字符,并把他们存到数组中;
字符输入流
FileReader
java.io.FileReader类是读取字符文件的类。构造时使用系统默认的字符编码和默认的字节缓冲区。
1.字符编码:字节与字符的对应规则。windows系统的中文编码默认是GBK。
2.字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法
- FileReader(File file ):创建一个新的FileReader,给指定要读取的File对象。
- FileReader(String filenaem):创建一个新的FileReader,给指定的文件名称。
举例:
public class test0 {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("G:\\aaa\\1.txt");
FileReader fileReader = new FileReader(file);
FileReader fileReader1 = new FileReader("G:\\aaa\\1.txt");
}
}
读取字符数据
public class test1 {
public static void main(String[] args) throws IOException {
//创建流对象
FileReader reader = new FileReader("1.txt");
//定义变量
int a;
//循环读取
while ((a=reader.read())!=-1){
System.out.println((char)a);
}
/**打印
* 博
* 主
* 真
* 帅
*/
reader.close();
}
}
使用字符数组读取
public class test3 {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("1.txt");
int a;
//定义数组,每次读2个
char[] C = new char[2];
while ((a=reader.read(C))!=-1){
System.out.println(new String(C));
}
reader.close();
}
}
字符输出流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 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
构造方法
- FileWriter(File file) : 创建一个新的 FileWriter,给定要读取的File对象。
- FileWriter(String fileName) : 创建一个新的 FileWriter,给定要读取的文件的名称
案例
public class test4 {
public static void main(String[] args) throws IOException {
File file = new File("1.txt");
FileWriter fileWriter = new FileWriter(file);
new FileWriter("1.txt");
}
}
写入数据
public class test5 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("1.txt");
fileWriter.write(88);
fileWriter.write('a');
fileWriter.write(30090);// 写出第4个字符,中文编码表中30000对应一个汉字。
//记得刷新
fileWriter.flush();
fileWriter.close();
/**
* 输出
* Xa疊
*/
}}
写出字符数组
public class test6 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("1.txt");
char [] r = "嘎嘎嘎".toCharArray();
//写入
fileWriter.write(r);
//写入从 从索引1开始 2个字节
fileWriter.write(r,1,2);
fileWriter.flush();
fileWriter.close();
}
}
写入字符串
public class test7 {
public static void main(String[] args) throws IOException {
//加true 是在1.txt里追加续写
FileWriter fileWriter = new FileWriter("1.txt",true);
String s="哈哈哈哈";
fileWriter.write(s);
fileWriter.flush();
fileWriter.close();
}
}