按数据流向分：
输入流：将数据读取到内存中
输出流：将数据从内存写入到指定的文件中
按操作方式分：
字节流：
InputStream：字节输入流的顶层抽象类
子类：FileInputStream:普通的字节输入流
BufferedInputStream:高效的自己输入流（字节缓冲输入流）
OutputStream：字节输入流的顶层抽象类
（类似于上）
字符流：
Reader：（类似于上）
Writer：（类似于上）
File类
就是用来操作文件（夹）路径的
构造方法：
File(String pathname) 根据给定的字符串路径创建其对应的File对象
File(String parent, String child) 根据给定的字符串形式的父目录和子文件（夹）名创建File对象
File(File parent, String child) 根据给定的父目录对象和子文件（夹）名创建File对象
成员方法：
创建功能：如果不存在就创建，返回true，否则就不创建，返回false
createNewFile():创建文件（返回boolean类型的结果）
mkdir()：创建单级目录
mkdirs():创建多级目录
判断功能：
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exists():判断File对象是否存在
public static void main(String[] args) throws IOException {
//需求：将 D:\abc\1.txt 封装成 File 对象
//方式一:根据字符串形式的路径获取File对象
File file1 = new File("D:\\abc\\1.txt");
System.out.println(file1);
//方式二：根据字符串形式的父目录以及子目录创建File对象
File file2 = new File("D:\\abc","1.txt");
System.out.println(file2);
//方式三：根据父目录对象以及字符串形式的子目录对象获取File对象
File file3 = new File("D:\\abc");
File file4 = new File(file3,"1.txt");
System.out.println(file4);
//需求：在D盘下创建 2.txt文件
File file5 = new File("d:/abc/2.txt");
boolean flag1=file5.createNewFile();
System.out.println(flag1);
//需求：在D盘下创建A文件夹（目录）
File file6 = new File("d:/A");
boolean flag2=file6.mkdir();
System.out.println(flag2);
//需求：创建多级目录
File file7 = new File("d:/B/C/D");
boolean flag3=file7.mkdirs();
System.out.println(flag3);
//测试判断功能
File file8 = new File("D:\\abc\\1.txt");
boolean flag4 = file8.isDirectory();
boolean flag5 = file8.isFile();
boolean flag6 = file8.exists();
System.out.println("测试file8是否为文件:"+flag4);
System.out.println("测试file8是否为目录:"+flag5);
System.out.println("测试file8是否存在:"+flag6);
}
成员方法：
getAbsolutePath()：获取绝对路径（以盘符开头的路径；例：D:/1.txt）；返回值为String类型
getPath()：获取文件相对路径（一般相对于当前项目路径来讲；例：1.txt）
getName()：获取文件名
list()：获取指定目录下所有文件（夹）名称数组
listFiles()：获取指定目录下所有文件（夹）File数组
public class test2 {
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);
System.out.println("-----------------------");
//获取 lib 文件夹下所有的文件（夹）的名称数组：String[]
File file2 = new File("BasicGrammar/lib");
String[] names = file2.list();
for (String name : names) {
System.out.println(name);
}
System.out.println("-----------------------");
//获取 lib 文件夹下所有的文件（夹）的 File 对象数组：String[]
File[] name1 = file2.listFiles();
for (File file : name1) {
System.out.println(file);
}
}
}
字符流读数据—按单个字符读取
-
创建字符流读文件对象：
Reader reader = new FileReader("......");
-
调用方法读取数据：
int data = reader.read(); 读取一个字符，返回该字符代表的整数，若到达流的末尾，返回-1
-
异常处理：
throws IOException
-
关闭资源
reader.close();
字符流读数据
Reader类中的方法：int read(); 读一个字符，返回该字符对应的ASCII码值，读不到返回-1；
FileReader类的构造方法：public FileReader(String pathname)：根据传入的字符串形式的路径，获取字符输入流对象
public class ReaderDemo1 {
public static void main(String[] args) throws IOException {
// 需求：通过字符流读取数据
//1. 创建字符输入流对象
Reader reader = new FileReader("BasicGrammar/lib/1.txt");
//2. 读取数据
// int data1 = reader.read();
// System.out.println(data1);
// int data2 = reader.read();
// System.out.println(data2);
// int data3 = reader.read();
// System.out.println(data3);
// int data4 = reader.read();
// System.out.println(data4);
/*
优化上述的读法，用循环改进，
又因为不知道循环次数，所以用while循环改进
*/
int ch;
while((ch = reader.read())!=-1){
System.out.println(ch);
}
//3. 释放资源
reader.close();
}
}
按字符数组读取
-
调用方法读取数据：
char[] chs = new char[2048];
int len = reader.read(chs);
读取字符到数组中，返回读取的字符数，若到达流的末尾，返回-1；
public class ReaderDemo02 {
public static void main(String[] args) throws IOException {
// 需求：通过字符流读取数据，一次读一个字符数组
//1.创建字符输入流对象
Reader reader = new FileReader("BasicGrammar/lib/2.txt");
//2. 读取数据
// char[] chs = new char[3];
// int len1 = reader.read(chs);
// System.out.println(len1);
// System.out.println(chs);
// int len2 = reader.read(chs);
// System.out.println(len2);
// System.out.println(chs);
// int len3 = reader.read(chs);
// System.out.println(len3);
// System.out.println(chs);
/*
优化上述代码，用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("目的地文件的路径")；
-
调用方法写入数据：
int x = '中'；
writer.write(x);//写一个字符
-
异常处理：
throws IOException
-
关闭资源：
writer.close();
按字符数组写入
-
创建字符流写文件对象：
Writer writer = new FileWriter("目的地文件的路径")；
-
调用方法写入数据：
char[] chs = {'你','爱','我'}；
writer.write(chs);//写一个字符数组
-
异常处理：
throws IOException
-
关闭资源：
writer.close();
按字符串写入
-
创建字符流写文件对象：
Writer writer = new FileWriter("目的地文件的路径")；
-
调用方法写入数据：
writer.write("好好学习，天天向上")；
-
异常处理：
throws IOException
-
关闭资源：
writer.close();
字符流写数据
Writer类中的方法
void write(int ch); 一次写一个字符
void write(char[] cha, int index, int len); 一次写一个指定的字符数组
viod write(String str); 一次写一个字符串
public class writerDemo {
public static void main(String[] args) throws IOException {
//需求：通过字符流写数据
//1. 创建字符输出对象
Writer writer = new FileWriter("BasicGrammar/lib/1.txt");
//2. 写数据
//一次写一个字符
// writer.write('好');
// //一次写一个指定的字符数组
// char[] chs = {'好','好','学','习'};
// writer.write(chs,1,3);
//一次写一个字符串
writer.write("好好学习");
//3.关闭资源
writer.close();
}
}
字符流拷贝文件—按单个字符读写
-
创建字符流读文件对象：
Reader reader = new FileReader("...");
-
创建字符流写文件对象：
Writer writer = new FileWriter("...");
-
调用方法读取数据：
int data = reader.read();
-
调用方法写入数据:
writer.write(data);
-
异常处理：
throws IOException
-
关闭资源：
reader.close();
writer.close();
IO流拷贝文件核心6步
-
创建字符输入流对象，关联数据源文件
-
创建字符输出流对象，关联目的地文件
-
定义变量，记录读取到的内容
-
循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
-
将读取到的数据写入到目的地文件中
-
释放资源
public class CopyDemo {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符
//将 1.txt 文件中的内容复制到 2.txt 中
//Reader reader = new FileReader("BasicGrammar/lib/1.txt");
//优化
FileReader reader = new FileReader("BasicGrammar/lib/1.txt");
//Writer writer = new FileWriter("BasicGrammar/lib/2.txt");
//优化
FileWriter writer = new FileWriter("BasicGrammar/lib/3.txt");//如果目的地文件不存在，程序会自动创建
int data;
while((data = reader.read())!= -1) {
writer.write(data);
}
reader.close();
writer.close();
}
}
按字符数组读写
-
创建字符流读文件对象：
Reader reader = new FileReader("...");
-
创建字符流写文件对象：
Writer writer = new FileWriter("...");
-
调用方法读取数据：
char[] chs = new char[2048];
int len = reader.read(chs);
-
调用方法写入数据:
writer.write(chs,0,len);
-
异常处理：
throws IOException
-
关闭资源：
reader.close();
writer.close();
public class CopyDemo02 {
public static void main(String[] args) throws IOException {
//需求：通过字符流拷贝文件，一次读写一个字符数组
FileReader fr = new FileReader("BasicGrammar/lib/1.txt");
FileWriter fw = new FileWriter("BasicGrammar/lib/2.txt");
int len;
char[] chs = new char[2048];
while((len = fr.read(chs))!= -1){
fw.write(chs,0,len);
}
fr.close();
fw.close();
}
}
字符缓冲流拷贝文件的标准代码
BufferedReader和BufferedWriter底层都有自己的默认缓冲区，底层会按照字符数组进行读写
-
创建字符流读文件对象：
BufferedReader br = new BUfferedReader(new FileReader("readme.txt"));
-
创建字符流写文件对象：
BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"));
-
异常处理：
throws IOException
-
使用while循环读写数据：
int len;
while((len = br.read())! = -1){
bw.write(len);
}
-
关闭资源
br.close();
bw.close();
字符缓冲流用法
分类：
BufferedReader：字符缓冲输入流（也叫高效字符输入流）
构造方法：public BufferedReader(Reader reader)
BufferedWriter：字符缓冲输出流（也叫高效字符输出流）
构造方法：public BufferedWriter(Writer writer)
public class CopyFile {
public static void main(String[] args) throws IOException {
// 需求：通过字符缓冲流，将 1.txt 中的内容拷贝到 2.txt 中
// 1.创建字符缓冲输入流对象，关联数据源文件
// 1.1创建普通的字符输入流对象
FileReader fr = new FileReader("BasicGrammar/lib/1.txt");
// 1.2 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(fr);
// 简化上述代码
//BufferedReader br = new BufferedReader(new FileReader("BasicGrammar/lib/1.txt"));
// 2.创建字符缓冲输出流对象，关联目的地文件
// 2.1创建普通的字符输出流对象
FileWriter fw = new FileWriter("BasicGrammar/lib/2.txt");
// 2.2 创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(fw);
// 3.定义变量，记录读取到的数据
int len;
// 4.循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
while((len = br.read())!= -1){
// 5.将读取到的数据写入到目的地文件中
bw.write(len);
}
// 6.释放资源
br.close();
bw.close();
}
}
字符缓冲流之一次读写一行
BufferedReader：字符缓冲输入流（也叫高效字符输入流）
成员方法：public String readLine();一次读取一行数据并返回读取到的内容，读不到返回null
BufferedWriter：字符缓冲输出流（也叫高效字符输出流）
成员方法：public void newLine();根据当前操作系统给出对应的换行符
public class CopyFile2 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("BasicGrammar/lib/1.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("BasicGrammar/lib/2.txt"));
String str;
while((str = br.readLine())!=null){
bw.write(str);
//千万别忘记换行
bw.newLine();
}
br.close();
bw.close();
}
}
字节流读写文件
字节流拷贝文件—按单个字节读写
-
创建字节流读文件对象
InputStream is = new FileInputStream("..."); -
创建字节流写文件对象
OutputStream os = new FileOutputStream("..."); -
异常处理
throws IOException -
使用while循环读写数据
int b;
while((b=is.read())!= -1){
os.write(b);
} -
关闭资源
is.close();
os.close();
字节流的用法
FileInputStream:普通的字节输入流，用来读取数据
构造方法：public FileInputStream(String pathname)
成员方法：public int read(); 一次读取一个字节，并返回读取到的内容，读不到返回 -1
FileOutputStream: 普通的字节输出流，用来写数据的
构造方法：public FileOutputStream(String pathname);
成员方法：public void write(int len); 一次写入一个字节
public class CopyFile3 {
public static void main(String[] args) throws IOException {
//需求：通过普通的字节流，一次读写一个字节的方式，将 a.jpg复制到 b，jpg
//1. 创建字节输入流，关联数据源文件
FileInputStream fis = new FileInputStream("...");
//2. 创建字节输出流，关联目的地文件
FileOutputStream fos = new FileOutputStream("...");
//3. 定义变量，用来记录读取到的内容
int len;
//4. 循环读取，只要条件满足就一直读，并将读取到的内容赋值给变量
while((len = fis.read())!= -1) {
//5. 将读取到的内容写入到目的地文件
fos.write(len);
}
//6. 释放资源
fis.close();
fos.close();
}
}
字节流拷贝文件—按字节数组读写
-
创建字节流读文件对象
InputStream is = new FileInputStream("..."); -
创建字节流写文件对象
OutputStream os = new FileOutputStream("..."); -
异常处理
throws IOException -
定义字节数组，每次读取2048个字节
byte[] a = new byte[2048]; -
使用while循环读写数据
int len;
while((len = is.read(b))!= -1){
os.write(b,0,len);
} -
释放资源
is.close();
os.close();FileInputStream:普通的字节输入流，用来读取数据
成员方法：public int read(byte[] a); 一次读取一个字节数组，将读取到的内容存入到数组中，并返回读取到的有效字节数，读不到返回 -1
FileOutputStream: 普通的字节输出流，用来写数据的
成员方法：public void write(byte[] a,int index,int len); 一次写入一个字节
public class CopyFile04 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("BasicGrammar/lib/a.jpg");
FileOutputStream fos = new FileOutputStream("BasicGrammar/lib/b.jpg");
//定义变量，用来接收读取到的内容
byte[] bys = new byte[2048];
//用来记录读取到的有效字节数
int len;
while((len = fis.read(bys))!=-1){
fos.write(bys,0,len);
}
fis.close();
fos.close();
}
}
字节缓冲流拷贝文件的标准代码
字节缓冲流的用法
BufferedInputStream:字节缓冲输入流，用来读取数据
构造方法：public BufferedInputStream(InputStream is);
成员方法：public int read();一次读取一个字节，并返回读取到的内容，读不到返回-1
BufferedOutputStream:字节缓冲输出流，用来写数据
构造方法：public BufferedOutputStream(OutputStream os);
成员方法：public void write(int len);一次写入一个字节
public class CopyFile05 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("BasicGrammar/lib/a.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("BasicGrammar/lib/c.jpg"));
int len;
while((len = bis.read())!= -1){
bos.write(len);
}
bis.close();
bos.close();
}
}
拷贝纯文本文件使用字符流，拷贝其他（图片、音频、视频等）使用字节流
