IO流
-
File类
-
字节流
- 字节输入流
- 字节输出流
-
字符流
- 字符输入流
- 字符输出流
-
缓冲区流
-
对象流
一.File类
File类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等。
File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。
- 常用方法
方法名 | 描述 |
---|---|
String getName() | 获取文件(夹)名 |
String getPath() | 获取文件(夹)路径 |
boolean exists() | 文件(夹)是否存在 |
boolean isFile() | 是否是一个文件 |
boolean isDirectory() | 是否是一个目录(文件夹) |
boolean createNewFile() | 创建一个文件 |
boolean mkdir() | 创建一个具体的文件夹 |
boolean mkdirs() | 创建多级文件夹 |
boolean delete() | 删除某个文件(夹) |
String [] list() | 返回某个文件夹下的所有文件(夹)名 |
File [] listFiles() | 获取某个文件夹下所有的文件(夹) |
- 常用构造方法
new File(File parent,String child );
new File(String parent,String child);
new File(String pathName);
@Test
public void Test1(){
//1.文件完整的路径
File file1 = new File("C:\\Users\\前\\Desktop\\新建文件夹\\day20-IO\\笔记\\imgs/image-20201104162721700.png");
//2.拆分文件夹路径和文件路径
File file2 = new File("C:\\Users\\前\\Desktop\\新建文件夹\\day20-IO\\笔记\\imgs/","image-20201104162721700.png");
//表示一个文件夹
File file = new File("C:\\Users\\前\\Desktop\\新建文件夹\\day20-IO\\笔记\\imgs/");
//3.文件夹对象和路径
File file3 = new File(file,"image-20201104162721700.png");
}
2.使用递归,输出某个文件夹下所有的文件,以及子文件夹中所以的文件。
@Test //遍历文件夹
public void test3(){
File file = new File("C:\\Users\\前\\Desktop\\新建文件夹\\day20-IO\\笔记");
//System.out.println(Arrays.toString(file.list()));
File[] files= file.listFiles();
show(files);
}
public void show(File[] files){
for (File file1 : files) {
if (file1.isDirectory()){
System.out.println(file1.getName()+"这是一个文件夹");
File[] files1 = file1.listFiles();
show(files1);
}else{
System.err.println(file1.getName()+"这是文件");
}
}
}
二.字节流
1.字节输入流
- 构造方法
new FileInputStream(String文件路径);
new FileInputStream(File文件对象);
- 使用步骤
1.创建输入流流对象
2.调用read方法
3.关闭流对象
- read方法:从字节输入流中读取数据
//无参,返回一个字节,表示读取一个字节数据
int read()
//传入一个字节数组,表示将读到的字节存入数组中,返回存入的字节个数
int read(byte[] bytes)
//传入一个字节数组,数组下标,存放个数,表示将读到的字节存入数组,从数组的第off+1个元素开始存放,共存放len个。返回实际存入的字节个数。
int read(byte[] b,int off,int len)
- 常用方法
//返回字节输入流中还有多少个可以读取的字节个数
int available();
//字节输入流
public class Hello1 {
@Test
public void test3() throws IOException {
//直接流对象
FileInputStream fileInputStream = new FileInputStream("src\\a.txt");
//调用read方法
byte[] bytes = new byte[fileInputStream.available()];
//从第off开始读,都len个
int r= fileInputStream.read(bytes,2,3);
//输出
System.out.println(Arrays.toString(bytes));
}
//测试字节输入流 ---一次只读多个字节
@Test
public void test2() throws IOException {
//相对路径
File f1 = new File("src\\a.txt");
//1.构建一条通向文件f2的管道---对象流
FileInputStream fileInputStream = new FileInputStream(f1);
//2.调用方法
byte[] bytes = new byte[fileInputStream.available()];
//读取到把文件中的字节数据存入数组bytes,返回读到的实际字节个数
int r= fileInputStream.read(bytes);
System.out.println(Arrays.toString(bytes));
//关闭资源
fileInputStream.close();
}
//测试字节输入流 ---一次只读一个字节
@Test
public void test1() throws IOException {
//绝对路径
File f1 = new File("E:\\Java基础\\day20\\src\\a.txt");
System.out.println(f1.exists());
//相对路径
File f2 = new File("src\\a.txt");
System.out.println(f1.exists());
//1.构建一条通向文件f2的管道---对象流
FileInputStream fileInputStream = new FileInputStream(f2);
//2.调用方法
int len=fileInputStream.available();
for (int i = 0; i <len ; i++) {
System.out.println(fileInputStream.read());
}
//关闭资源
fileInputStream.close();
}
}
2.字节输出流
- 构造方法
new FileOutputStream(String);
new FileOutputStream(String,Boolean);
new FileOutputStream(File);
new FileOutputStream(File,Boolean);
- 使用步骤
1.创建输出流对象
2.调用write方法
3.关闭流对象
- write方法:向字节输出流中写入数据
//写入一个字节数据b
void write(int b);
//将字节数组b写入输出流中
void write(byte[] b);
//从字节数组b的第off+1个元素开始,向输出流中写入len个字节
void write(byte[] b,int off,int len);
案例
将下面的语句写入一个文本文件中:
I know,I'm not good enough, but I'm the only one in the world. Please cherish it.我知道,我不是最好的,但我是这个世界上独一无二的,请珍惜!
扩充:带缓冲区字节输入流和输出流
BufferedInputStream
BufferedOutputStream
//对比FileInputStream和FileOutputStream,测试读或写10000次的耗时
案例2–复制文件
结合字节输入流和输出流,边读边写,将某个文件复制到磁盘另一个位置。
2种方式:
- 创建一个比较大的数组,将输入流中所有的数据读取到数组中,再将数组中所以的数据一次写入输出流
- 结合while循环,一次读一个字节,写一个字节,边读边写。
//结合字节输入流和输出流 边读边写,将某个文件复制到磁盘另一个位置
public class Hello3 {
@Test
public void test1() throws Exception {
FileInputStream fi = new FileInputStream("src/a.txt");
//第二个参数 true 表示在原来后面追加 不会是覆盖
FileOutputStream fo = new FileOutputStream("src/b.txt",true);
//1.
while (fi.available()>0){
fo.write(fi.read());
}
}
}
三.字符流
读写字符数据文件:txt文件
1.字符输入流
- 构造方法
new FileReader(String);
new FileReader(File);
- 使用步骤
1.构建流对象
2.调用read方法
3.关闭流对象
- read方法:从字符输入流中读取字符数据
//读取一个字符,并返回读到的字符,如果没有读到,返回-1
int read();
//读取到的字符存入字符数组c
read(char[] c);
//读取到的字符存入字符数组c,从下标offset开始,个数为len
read(char[] c,int offset,int len);
public class Test1 {
//字符缓冲输入流
@Test
public void test4() throws Exception{
BufferedReader bufferedReader = new BufferedReader(new FileReader("src/a.txt"));
//bufferedReader.lines();
System.out.println(bufferedReader.readLine());
}
@Test //字符缓冲输出流
public void test3() throws Exception {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src/a.txt"));
bufferedWriter.write("昨夜雨疏风骤,浓睡不消残酒。");
bufferedWriter.newLine();
bufferedWriter.write("试问卷帘人,却道海棠依旧。知否,知否?应是绿肥红瘦。");
bufferedWriter.close(); //需要close 才会显示
}
@Test //2.字符输出流
public void test2() throws Exception {
FileWriter fileWriter = new FileWriter("src/a.txt");
fileWriter.write("灌灌灌灌灌");
fileWriter.close(); //需要close 才会显示
}
@Test //1.字符输入流
public void test1() throws Exception {
FileReader fileReader = new FileReader("src/a.txt");
char[] cs=new char[6];
int r1=-1;
while ((r1=fileReader.read(cs))!=-1){
System.out.println(cs);
}
}
}
案例
创建一个文本文件,写入:空山不见人,但闻人语响。返景入深林,复照青苔上。
使用字符输入流读取文本内容,输出在控制台。
输出效果如下:
空山不见人,
但闻人语响。
返景入深林,
复照青苔上。
@Test //1.字符输入流
public void test1() throws Exception {
FileReader fileReader = new FileReader("src/a.txt");
char[] cs=new char[6];
int r1=-1;
while ((r1=fileReader.read(cs))!=-1){
System.out.println(cs);
}
}
2.字符输出流
- 构造方法
new FileWriter(String);
new FileWriter(String,boolean);
new FileWriter(File);
new FileWriter(File,boolean);
- write方法:向字符输出流中写入字符数据
//写入一个字符
void write(int c)
//写入一个字符串
void write(String str)
//写入一个字符数组
void write(char[] c)
//写入一个字符串,从off开始,写len个
void write(String str,int off,int len)
//写入一个字符数组,从off开始,写len个
void write(char[] c,int off,int len)
案例
请把下面的话写入一个文本文件中:
昨夜雨疏风骤,浓睡不消残酒。试问卷帘人,却道海棠依旧。知否,知否?应是绿肥红瘦。
@Test //字符缓冲输出流
public void test3() throws Exception {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src/a.txt"));
bufferedWriter.write("昨夜雨疏风骤,浓睡不消残酒。");
bufferedWriter.newLine();
bufferedWriter.write("试问卷帘人,却道海棠依旧。知否,知否?应是绿肥红瘦。");
bufferedWriter.close(); //需要close 才会显示
}
四.其它流–扩展
1.缓冲流
- BufferedInputStream
- BufferedOutputStream
//字符缓冲输入流
@Test
public void test4() throws Exception{
BufferedReader bufferedReader = new BufferedReader(new FileReader("src/a.txt"));
//bufferedReader.lines();
System.out.println(bufferedReader.readLine());
}
@Test //字符缓冲输出流
public void test3() throws Exception {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("src/a.txt"));
bufferedWriter.write("昨夜雨疏风骤,浓睡不消残酒。");
bufferedWriter.newLine();
bufferedWriter.write("试问卷帘人,却道海棠依旧。知否,知否?应是绿肥红瘦。");
bufferedWriter.close(); //需要close 才会显示
}
- BufferedReader
- BufferedWriter
2.转换流
- InputStreamReader
- OutputStreamWriter
@Test
public void test1() throws Exception {
//由字节流转字符流
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("src/a.txt"));
//转换流结合缓冲流
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
bufferedReader.readLine();
}
3.数据流
- DataInputStream
- DataOutputStream
4.对象流 -----还需借助字节流
- ObjectInputStream
- ObjectOutputStream
实体类实现一个
空接口Serializable
该类的对象才可以实例化
/*
对象流 还需借助字节流
ObjectInputStream
ObjectOutputStream
```java
//实体类实现一个空接口Serializable 该类的对象才可以实例化
public class Monkey implements Serializable {
private String name;
@Override
public String toString() {
return "Monkey{" +
"name='" + name + '\'' +
'}';
}
public Monkey() {
}
public Monkey(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
将Java对象写入文本中保存----序列化
*/
@Test
public void test2() throws Exception{
//1.将Java对象写入文本中保存----序列化
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("src/a.txt"));
objectOutputStream.writeObject(new Monkey("kaka"));
//2.将文件中保存的对象读取到程序----反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("src/a.txt"));
Monkey m = (Monkey) objectInputStream.readObject();
System.out.println(m);
}