File类
我们可以把计算机中所有的文件，文件夹封装成一个File对象
public class File implements Serializable, Comparable<File> {
//有参构造方法，参数为该文件的路径
public File(String pathname) {
if (pathname == null) {
throw new NullPointerException();
}
this.path = fs.normalize(pathname);
this.prefixLength = fs.prefixLength(this.path);
}
//是否存在
public boolean exists(){}
//是否是文件
public boolean isFile() {}
//是否是文件夹
public boolean isDirectory() {}
//创建该文件夹
public boolean mkdir() {}
//创建该文件
public boolean createNewFile() throws IOException {}
public File[] listFiles() {}
public String getName() {}
public boolean delete() {}
public boolean renameTo(File dest) {}
}
流
我们可以通过流，来写入或者读取文件中信息。
分类
按照方向
无论输入，输出相对的都是程序
输入流
（1,0）流入到程序中,读取文件
输出流
流从程序中流出，相当于写入文件
按照单位
字节流
一次读取一个字节，字节流 byte
字符流
一次读取一个字符，字符流
字节输入流
InputStream 字节输入流使用来读取文件，一次读取一个字节
//一次读取一个字节
public abstract int read() throws IOException;
//一次读取一个字节，然后放入到数组中
public int read(byte b[]) throws IOException {
return read(b, 0, b.length);
}
package com.qfedu;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Demo03 {
public static void main(String[] args) throws IOException {
/*
* 字节输入流 读取文件 一次读取一个字节
*/
//待读取的文件
File file = new File("D:\\java2203\\first.txt");
//创建该文件的字节输入流
InputStream is = new FileInputStream(file);
/*
//读取文件 一次读取一个字节 abcdefg
int b1 = is.read(); // a 97
int b2 = is.read(); // b 98
int b3 = is.read(); // c 99
int b4 = is.read(); // d 100
int b5 = is.read(); // e 101
int b6 = is.read(); // f 102
int b7 = is.read(); // g 103
int b8 = is.read(); //-1
System.out.print((char)b1);
System.out.print((char)b2);
System.out.print((char)b3);
System.out.print((char)b4);
System.out.print((char)b5);
*/
int b;
while((b = is.read()) != -1) {
System.out.print((char)b);
}
is.close();
}
}
package com.qfedu;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Demo03_2 {
public static void main(String[] args) throws IOException {
/*
* 把读取到的字节放入一个数组中
*/
File file = new File("D:\\java2203\\first.txt");
InputStream is = new FileInputStream(file);
byte[] bs = new byte[3];
//abcdefg a b c, d e f, g 0 0
/*
int n1 = is.read(bs);
System.out.println(Arrays.toString(bs)+ n1);
System.out.println(new String(bs, 0, 3));
int n2 = is.read(bs);
System.out.println(Arrays.toString(bs)+n2);
System.out.println(new String(bs, 0, 3));
int n3 = is.read(bs);
System.out.println(Arrays.toString(bs)+n3);
System.out.println(new String(bs, 0, 1));
int n4 = is.read(bs);
System.out.println(n4);
*/
int n; //读取的字节数
while((n = is.read(bs)) != -1) {
System.out.print(new String(bs, 0, n));
}
}
}
字节输出流
OutputStream 字节输出流使用来写入文件，一次写入一个字节
//一次写入一个字节
public abstract void write(int b) throws IOException;
//一次写入一个字节数组
public void write(byte b[]) throws IOException {}
//一次写入一个字节数组指定位置的字节
public void write(byte b[], int off, int len) throws IOException {}
package com.qfedu;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo04 {
public static void main(String[] args) throws IOException {
//待写入的文件
File file = new File("D:\\java2203\\your.txt");
/*
* 创建该文件对象的输出流
* 如果定义添加参数true,则为追加
* 没有参数true,则为替换
*
*/
OutputStream os = new FileOutputStream(file, true);
//每次写入一个字节
os.write(97); //a
os.write(98); //b
os.write('c');
byte[] bs = {100,101,102,103};
os.write(bs);
byte[] bs2 = new byte[10];
bs2[0] = 104;
bs2[1] = 105;
os.write(bs2, 0, 2);
os.close();
}
}
复制文件
复制文件思路：
把使用字节输入流读取到的字节，写入到指定文件中，边读取边写入，达到一个复制的效果。
package com.qfedu;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Demo05_copy {
/*
* 使用字节输入，输出，完成复制功能
*/
public static void main(String[] args) throws IOException {
//定义待复制的文件
File file = new File("D:\\java2203\\apache-maven-3.3.9-bin.zip");
//定义复制到的目标文件
File targetFile = new File("D:\\java2203\\apache-maven-bin.zip");
targetFile.createNewFile();
//读取待复制文件 获取他的输入流
InputStream is = new FileInputStream(file);
//写入到目标文件 获取他的输出流
OutputStream os = new FileOutputStream(targetFile);
int b;
byte[] bs = new byte[1024];
while((b = is.read(bs)) != -1) {
os.write(bs, 0, b);
}
//关闭资源
is.close();
os.close();
}
}
缓冲字节输入流
内部做了优化，减少了和磁盘的交互，提高了字节读取的效率
方法的使用和字节输入流一模一样
package com.qfedu;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo06 {
/*
* 缓冲字节输入流
*/
public static void main(String[] args) throws IOException {
//字节输入流
InputStream is = new FileInputStream("D:\\java2203\\first.txt");
//字节输入流，才能创建缓冲字节输入流
BufferedInputStream bis = new BufferedInputStream(is);
int b;
byte[] bs = new byte[4];
while((b = bis.read(bs)) != -1) {
System.out.print(new String(bs, 0, b));
}
is.close();
bis.close();
}
}
缓冲字节输出流
内部做了优化，减少了和磁盘的交互，提高了字节读取的效率
方法的使用和字节输出流一模一样
注意：在最后flush()一下,确保缓存中的数据都写入到磁盘中
package com.qfedu;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo07 {
public static void main(String[] args) throws IOException {
//待写入的文件
File file = new File("D:\\java2203\\your.txt");
//字符输出流
OutputStream os = new FileOutputStream(file, true);
//通过字符输出流 获取缓冲字节输出流
BufferedOutputStream bos = new BufferedOutputStream(os);
String str = "hello world";
byte[] bytes = str.getBytes();
bos.write(bytes);
bos.flush(); // 抖一抖，把缓冲数据全部写入磁盘中
os.close();
}
}
字符输入流
字符输入流读取数据，每次读取一个字符
package com.qfedu;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo08 {
/*
* 字符输入流 : 读取文件，一次读取一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\his.txt");
//获取该文件的字符输入流
Reader reader = new FileReader(file);
//你自横刀向天笑，去留肝胆两昆仑。
int c;
while((c = reader.read()) != -1) {
System.out.print((char)c);
}
reader.close();
}
}
package com.qfedu;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo08_2 {
/*
* 字符输入流 : 读取文件，一次读取一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\his.txt");
//获取该文件的字符输入流
Reader reader = new FileReader(file);
//你自横刀向天笑，去留肝胆两昆仑。
int n;
char[] cs = new char[3];
while((n = reader.read(cs)) != -1) {
System.out.print(new String(cs, 0, n));
}
reader.close();
}
}
字符输出流
字符输出流写入数据，每次写入一个字符
package com.qfedu;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo09 {
/*
* 字符输出流，写入到这个文件, 每次写入一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\her.txt");
//获取该文件的字符输出流，写入到这个文件中
Writer writer = new FileWriter(file);
writer.write(97); //写入一个字符
char[] arr = {98,99};
writer.write(arr); //写入一个字符数组
writer.write("defg"); // 直接写入字符串
writer.close();
}
}
缓冲字符输入流
用法和缓冲字符输入流是一样的
多了一个读取一行数据的方法
package com.qfedu;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo10 {
/*
* 字符输入流 : 读取文件，一次读取一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\his.txt");
//获取该文件的字符输入流
Reader reader = new FileReader(file);
//缓冲字符输入流
BufferedReader br = new BufferedReader(reader);
//你自横刀向天笑，去留肝胆两昆仑。
int c;
while((c = br.read()) != -1) {
System.out.print((char)c);
}
reader.close();
br.close();
}
}
package com.qfedu;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo11 {
/*
* 字符输入流 : 读取文件，一次读取一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\his.txt");
//获取该文件的字符输入流
Reader reader = new FileReader(file);
/*
* 缓冲字符输入流
*
* 可以一次读取一行
*/
BufferedReader br = new BufferedReader(reader);
//你自横刀向天笑，去留肝胆两昆仑。
String str;
while ((str=br.readLine()) != null) {
System.out.println(str);
}
reader.close();
br.close();
}
}
缓冲字符输出流
缓冲字符输出流和字符输出流的用法是一样的
多了一个nextLine()方法，换行方法
package com.qfedu;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo12 {
/*
* 字符输出流，写入到这个文件, 每次写入一个字符
*/
public static void main(String[] args) throws IOException {
File file = new File("D:\\java2203\\her.txt");
//获取该文件的字符输出流，写入到这个文件中
Writer writer = new FileWriter(file);
//获取该文件的字符输出缓冲流
BufferedWriter bw = new BufferedWriter(writer);
bw.write(97); //写入一个字符
char[] arr = {98,99};
bw.write(arr); //写入一个字符数组
bw.newLine(); //换行
bw.write("呵呵哒"); // 直接写入字符串
bw.flush();
writer.close();
bw.close();
}
}