File类
概念
文件，文件夹，一个file对象代表磁盘上的某个文件或者文件夹
构造方法
File(String pathname)
File(String parent,String child)
File(File parent, String child)
成员方法
creatNewFile():创建文件
mkdir()和mkdirs():创建目录（即创建文件夹）
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exicts()：判断File对象是否存在
package cn.itcast.demo20;
/*
File类：
概述：
文件，文件夹，一个File对象代表磁盘上的某个文件夹。也就是用来操作文件（夹）路径的。
构造方法：
File(String pathname) 根据给定的字符串路径创建其对应的File对象
File(String parent, String child)根据给定的字符串形式的父目录和子文件（夹）名创建File对象
File(File parent, String child)根据给定的父母目录对象和子文件（夹）名创建File对象
成员方法：
创建功能：如果不存在就创建，返回true,否则就不存在，返回false
createNewFile():创建文件夹
mkdir(): 创建单级目录
mkdirs():创建目录
判断功能：
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exists():判断File对象是否存在
*/
import java.io.File;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
//需求: 将 D:\abc\1.txt 封装成File对象.
//方式一: 根据字符串形式的路径获取File对象.
//File file1 = new File("D:\\abc\\1.txt");
File file1 = new File("D:/abc/1.txt");
System.out.println("file1: " + file1);
//方式二: 根据字符串形式的父目录以及子目录创建File对象.
File file2 = new File("D:/abc/", "1.txt");
System.out.println("file2: " + file2);
//方式三: 根据父目录对象, 以及字符串形式的子目录来获取File对象.
File file3 = new File("D:/abc/");
File file4 = new File(file3, "1.txt");
System.out.println("file4: " + file4);
System.out.println("-----------------------------");
System.out.println("创建功能");
//需求: 在f:盘下创建 b.txt文件(我的在D盘里面创建不了b.txt 文件，会报错， 所有要换一个文件的路径改为f盘或者其他盘。不区分盘的大小写)
File file5 = new File("f:/b.txt");
boolean flag1 = file5.createNewFile();
System.out.println("flag1: " + flag1);
//需求: 在D:盘下创建 a文件夹
File file6 = new File("D:/a");
boolean flag2 = file6.mkdir();//make directory:创建单级目录
System.out.println("flag2:" + flag2);
//需求：在D盘创建a/b/c文件夹：即文件夹a下包含文件夹b，文件夹b下包含文件夹c.即创建多级路径
File file7 = new File("D:/a/b/c");
boolean flag3 = file7.mkdirs();//mkdirs可以创建多级目录也可以创建单级目录
System.out.println("flag3:" + flag3);
System.out.println("==============");
System.out.println("测试判断功能");
File file8 = new File("D:/a/b");
/* boolean flag4 = file8.isDirectory();
System.out.println("测试file8是否是文件夹:" + flag4);*/
//上面注释的是标准的写法
System.out.println("测试file8是否是文件夹:" + file8.isDirectory());
System.out.println("测试file8是否是文件:" +file8.isFile());
System.out.println("测试file8是否是存在:" + file8.exists());
}
}
成员方法
getAbsolutePath():获取绝对路径
绝对路径：以盘符开头的路径
例如：D:/1.txt
getPath():获取文件的相对路径
相对路径：一般是相对于当前项目路径来讲的。
例如：1.txt
getName():获取文件名
list():获取指定目录下所有文件（夹）名称数组
listFiles():获取指定目录下所有文件（夹）File数组
package cn.itcast.demo21;
/*
File类的获取功能:
getAbsolutePath():获取绝对路径
getPath():获取文件的相对路径
getName():获取指定目录下所有文件（夹）名称数组
list():获取指定目录下所有文件(夹)File数组
listFile():获取指定目录下所有文件（夹）File数组
Java中路径的划分：
绝对路径：
以盘符开头的路径，固定的，写“死”的路径
相对路径：
意思是相对某个路径而言，Java中的相对路径是指：相对于当前项目的路径来讲的
*/
import java.io.File;
public class Test {
public static void main(String[] args) {
File file1 = new File("lib/1.txt");
//获取file1的绝对路径
String path1 = file1.getAbsolutePath();
System.out.println("绝对路径: " + path1);
//获取file1的相对路径
String path2 = file1.getPath();
System.out.println("相对路径:" + path2);
//获取文件名
String fileName = file1.getName();
System.out.println("文件名:" + fileName);
//获取lib文件夹下所有的文件（夹）的：名称数组String[]
File file2 = new File("lib");
String[] names = file2.list();
for (String name : names){
System.out.println(name);
}
System.out.println("==================");
//获取lib文件夹下所有的文件（夹）的：File对象数组File[]
File[] files= file2.listFiles();
for(File file:files){
System.out.println(file);
}
}
}
输出结果：
绝对路径: C:\Users\HP\Desktop\besttj\lib\1.txt 相对路径:lib\1.txt 文件名:1.txt 1.txt a
abc
lib\1.txt lib\a lib\abc
Process finished with exit code 0
字符流读写文件
字符流读数据-按单个字符读取
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
调用方法读取数据：
int data = reader.read();
读取一个字符，返回该字符代表的整数，若到达流的末尾，返回-1
异常处理：
throws IOException
关闭资源：
reader.close();
package cn.itcast.demo22;
/*
字符流读数据：
Reader 类中的方法：
int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
FileReader类的构造方法：
public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo01 {
public static void main(String[] args) throws FileNotFoundException, IOException {
//需求：通过字符流读取数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
int ch1 = reader.read();
System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
int ch2 = reader.read();
System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
int ch3 = reader.read();
System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
int ch4 = reader.read();
System.out.println(ch4);//输出-1,因为已经到字符串末尾了
//3.释放资源
reader.close();
}
}
package cn.itcast.demo22;
/*
字符流读数据：
Reader 类中的方法：
int read(): 读一个字符，返回该字符对应的ASCII码值，读不到返回-1
FileReader类的构造方法：
public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo01 {
public static void main(String[] args) throws FileNotFoundException, IOException {
//需求：通过字符流读取数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/1.txt");
//2.读取数据
/*int ch1 = reader.read();
System.out.println(ch1);//输出了lib/1.txt文件中abc 中a的ascii值97
int ch2 = reader.read();
System.out.println(ch2);//输出了lib/1.txt文件中abc 中b的ascii值98
int ch3 = reader.read();
System.out.println(ch3);//输出了lib/1.txt文件中abc 中c的ascii值99
int ch4 = reader.read();
System.out.println(ch4);//输出-1,因为已经到字符串末尾了*/
/*
优化上述的读法，用循环改进
又因为不知道循环的次数，所有用while循环
*/
//定义变量，用来接收读取到的字符
int ch;
/*
(ch=reader.read())!= -1 这句代码做了三件事
1.执行reader.read() 去文件中读取一个字符
2.执行ch=reader.read()将读取到的字符赋值变量
3.（ch=reader.read()）！= -1，用读取到的字符（内容）和-1进行比较
*/
while((ch=reader.read())!= -1){
//ch = reader.read();
System.out.println(ch);
}
//3.释放资源
reader.close();
}
}
创建字符流读数据-按字符数组读取
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
调用方法读取数据：
char[] chs = new char[2048];
int len = r.read(chs);
读取字符到数组中，返回读取的字符数，若到达流的末尾，返回-1
异常处理
throws IOException
关闭资源：
reader.close();
package cn.itcast.demo22;
/*
字符流读数据：
Reader类中的方法：
int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
并返回读取到的有效字符流，读不到返回-1
FileReader类的构造方法:
Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo02 {
public static void main(String[] args) throws IOException {
//需求：通过字符流读取数据，一次读取一个字符数据
//1.创建字符输入流对象 2.txt里面只有abcdefg这个字符串
Reader reader = new FileReader("lib/2.txt");
//2.读取数据
char[] chs = new char[3];//字符数组初始长度为3
int len1 = reader.read(chs);
System.out.println(chs);//a,b,c
System.out.println(len1);//返回值为3
int len2 = reader.read(chs);
System.out.println(chs);//d,e,f
System.out.println(len2);//返回值为3
int len3 = reader.read(chs);
System.out.println(chs);//g,e,f 最后只剩g所以返回值为1，但是要返回三个，那么前面的def只有d被g覆盖了，其余的不变，因为没有字母进行e和f的覆盖
System.out.println(len3);//返回值为1
int len4 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len4);//返回值为-1
//3.释放资源
reader.close();
}
}
package cn.itcast.demo22;
/*
字符流读数据：
Reader类中的方法：
int read(char[] chs): 一次读一个字符数组，将读取到的内容存入到数组中
并返回读取到的有效字符流，读不到返回-1
FileReader类的构造方法:
Public FileReader(String pathname):根据传入的字符串形式的路径，获取字符输入流对象
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo02 {
public static void main(String[] args) throws IOException {
//需求：通过字符流读取数据，一次读取一个字符数据
//1.创建字符输入流对象
Reader reader = new FileReader("lib/2.txt");
//2.读取数据
/*char[] chs = new char[3];//字符数组初始长度为3
int len1 = reader.read(chs);
System.out.println(chs);//a,b,c
System.out.println(len1);//返回值为3
int len2 = reader.read(chs);
System.out.println(chs);//d,e,f
System.out.println(len2);//返回值为3
int len3 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len3);//返回值为1
int len4 = reader.read(chs);
System.out.println(chs);//g,e,f
System.out.println(len4);//返回值为-1*/
/*
优化上述的代码，while循环
*/
//定义字符数组
char[] chs = new char[3];
//定义一个变量，记录读取到的有效字符数
int len;
while((len = reader.read(chs))!=-1){
//将读取到的内容，转换成字符串，然后打印
/*
chs :表示要操作的数组
0:表示起始索引
len:表示要操作的字符个数
*/
String s = new String(chs,0,len);//传字符数组、起始索引、长度
System.out.println(s);
}
//3.释放资源
reader.close();
}
}
字符流写数据-按单个字符写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写入数据
int x = '中';
writer.write(x);
写一个字符
异常处理
throws IOException
关闭资源
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//3.释放资源
writer.close();
}
}
字符流写数据-按字符数组写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写数据：
char[] chs = {'橙','心','橙','意'};
writer.write(chs);
写一个字符数组
异常处理：
throws IOException
关闭资源：
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
// writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//一次写一个指定的字符数组
char[] chs = {'黑','马','程','序','员'};
writer.write(chs,2,3);
//3.释放资源
writer.close();
}
}
字符流写数据-按字符串写入
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法写入数据：
writer.write("小黑爱学习");
写入一个字符串
异常处理：
throws IOException
关闭资源：
writer.close();
package cn.itcast.demo23;
/*
字符流写数据：
Writer类中的方法：
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len):一次写一个指定的字符数组
void write(String str):一次写一个字符串
FileWriter 类的构造方法:
public FileWriter(String pathname):根据传入的字符串形式的路径，获取字符输出流对象
*/
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo01 {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1.创建字符输出流对象
Writer writer = new FileWriter("lib/1.txt");
//2.写数据
//一次写一个字符
// writer.write('好');//把原来1.txt文件里面的abc给覆盖了 abc被覆盖为好
//一次写一个指定的字符数组
/* char[] chs = {'黑','马','程','序','员'};
writer.write(chs,2,3);*/
//一次写一个字符串
writer.write("好好学习，知识改变命运");
//3.释放资源
writer.close();
}
}
字符流读写数据
字符流拷贝文件-按单个字符读写
创建字符流读文件对象：
Reader reader = new FileReader("readme.txt");
创建字符流写文件对象
Writer writer = new FileWriter("dest.txt");
调用方法读取数据
int data = reader.read();
调用方法写入数据
writer.write(data);
异常处理
throws IOException
关闭资源
reader.close();
writer.close();
package cn.itcast.demo24;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile1 {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符
//例如。将1.txt文件中的内容复制到2.txt文件中
/*
IO流拷贝文件核心六步：
1.创建字符输入流对象，关联数据源文件
2.创建字符输出流对象，关联目的地文件
3.定义变量，记录读取的内容
4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//1.创建字符输入流对象，关联数据源文件
//Reader reader = new FileReader("lib/1.txt");下面是这个代码的优化写法
FileReader fr = new FileReader("lib/1.txt");
//2.创建字符输出流对象，关联目的地文件
FileWriter fw = new FileWriter("lib/3.txt");//细节：如果目的地文件不存在，程序会自动创建
//3.定义变量，记录读取的内容
int len;
//4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
while ((len = fr.read())!=-1){
//5.将读取到的数据写入到目的地文件中
fw.write(len);
}
//6.释放资源
fr.close();
fw.close();
}
}
字符流拷贝文件-按字符数组读写
创建字符流读文件对象：
Reader reader = new FileReader("reader.txt");
创建字符流写文件对象：
Writer writer = new FileWriter("dest.txt");
调用方法读取数据：
char[] chs = new char[2048];//字符数组的长度最好定义为1024的整数倍， 计算机底层的换算单位是1024的整数倍
int len = reader.read(chs);
调用方法写数据：
writer.write(chs,0,len);
异常处理：
throws IOException
关闭资源
reader.close();
writer.close();
package cn.itcast.demo24;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CopyFile2 {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符数组
//例如：将1.txt文件中的内容复制到2.txt文件中
/*
IO流核心六步：
1.创建字符流输入流对象，关联数据源文件
2.创建字符输出流对象，关联目的地文件
3.创建变量，用来记录读取到的有效字符数
4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
//1.创建字符流输入流对象，关联数据源文件
FileReader fr = new FileReader("lib/1.txt");
//2.创建字符输出流对象，关联目的地文件
FileWriter fw = new FileWriter("lib/2.txt");
//3.创建变量，用来记录读取到的有效字符数
char[] chs = new char[1024];
//用来记录读取到的有效字符数
int len;
//4.通过循环进行读取，只要条件满足就一直读，并将读取到的有效数赋值给变量
while ((len = fr.read(chs))!= -1){
//5.将读取到的数据写入到目的地文件中
fw.write(chs,0,len);
}
//6.释放资源
fr.close();
fw.close();
}
}