IO继承关系
io.jpg
1.File类
- File表示的是文件（目录）
- File类只用于表示文件（目录）的信息（名称、大小等）， 不能用于文件内容的访问
- 在某些流方法中可以使用表示路径的字符串代替File对象
构造器
/**
* 在不传入绝对路径的情况下，默认使用相对路径，即使用 该项目工程的路径；
* 目录分级使用 / 表示，也就是Linux系统的分级符（本文代码使用Windows系统环境编译）
*/
//方式一：直接传入路径
File file2 = new File("D:\\logs\\文本.txt");
//方式二：第一个参数代表父路径，第二个参数代表子路径，常用语表示某路径(第一个参数)下的某个文件(第二个参数)
File file = new File("D:\\logs","文本.txt");
常用方法
File file = new File("");
//列出当前目录下的子目录和文件名，不包含父目录名和子孙目录，返回字符串数组
file.list();
//返回直接子目录（文件）的抽象，表示目录的绝对路径
file.listFiles();
//判断目录或文件是否存在
file.exists();
//判断是否是目录
file.isDirectory();
//创建新目录，只创建一级
file.mkdir();
//创建多级目录，
file.mkdirs();
//判断是否是文件
file.isFile();
//创建新的文件
file.createNewFile();
//删除目录或文件
file.delete();
//获取绝对路径，返回String
file.getAbsolutePath();
//获取文件名，返回String
file.getName()
//获取父路径，返回String
file2.getParent();
案例
//案例一：判断目录是否存在，存在 ? 删除 : 新建;（同理可判断文件）
private void fileTest(File file){
if (!file.exists()){
file.mkdir();//只创建一级目录；file.mkdirs()可创建多级目录
}else {
file.delete(); //删除目录
}
}
//案例二：列出指定目录下的以.java后缀结尾所有文件，包含子目录
private void listDirectory(File dir){
if(!dir.exists()){
throw new IllegalArgumentException("目录"+dir+"不存在");
}
if (!dir.isDirectory()){
throw new IllegalArgumentException(dir+"不是目录");
}
File[] files = dir.listFiles(); //返回直接子目录（文件）的抽象
if (null!= files && files.length>0){
for (File file : files){
if (file.isDirectory()){
listDirectory(file);
}else {
if (file.getName().endsWith(".java"))
System.out.println(file);
}
}
}
}
2、字节流
① InputStream、OutputStream (抽象类)
- InputStream抽象了应用程序读取数据的方式
- OutputStream抽象了应用程序写出数据的方式
② EOF = End 读到-1就到结尾 - ③ 输入流基本方法
- int b = in.read(); 读取一个字节无符号填充到int低八位，-1是EOF
- in.read(byte[] buf);
- in.read(byte[] buf,int start,int size);
- ④ 输出流基本方法
- out.write(int b); 写出一个字节到流，b的低八位
- out.write(byte[] buf);将buf字节数组都写入到流
- out.write(byte[] buf,int start,int size); buf字节数组从start开始写，写size长度
- ⑤ FileInputStream :具体实现了在文件上读取数据
一、 FileInputStream、FileOutputStream
- FileInputStream：用于从文件中读取信息
- FileOutputStream：用于将信息写入文件
构造器
//通过传入File对象或直接传表示路径的字符串
FileInputStream in = new FileInputStream(new File(""));
FileOutputStream out = new FileOutputStream(new File(""));
//FileOutputStream构造器有第二个参数可选，传入boolean值，true:表示在原文件内容之后追加写入内容，
//false：默认值，可不传，表示清空原文件，重新写入
案例
//文件拷贝
/**
* 文件拷贝 （此方法效率最高）
*
* @param srcFile
* @param destFile
*/
public static void copyFile(File srcFile,File destFile) throws IOException {
if (!srcFile.exists()){
throw new IllegalArgumentException("文件"+srcFile+"不存在");
}
if (!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
byte[] buf = new byte[8*1024];
int b;
while ((b=in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out.flush();
}
in.close();
out.close();
}
二、BufferedInputStream、BufferedOutputStream
- BufferedInputStream：可以防止每次读取时都得进行实际写操作
- BufferedOutputStream：可以米面每次发送数据时都要进行实际的写操作，注意： 每次写完之后调用flush()方法，以刷新缓冲区
构造器
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
案例
/**
* 带缓冲的文件拷贝方式（此处仅演示用法，文件拷贝不推荐使用此方式）
*
* 缓冲操作，一般打开文件进行写入操作或读取操作时（非拷贝），都会加上缓冲，可提高IO性能
*/
public static void copyFileByBuffered(File srcFile,File destFile) throws IOException {
if (!srcFile.exists()){
throw new IllegalArgumentException("文件"+srcFile+"不存在");
}
if (!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
int c;
while ((c=bis.read())!=-1){
bos.write(c);
bos.flush();
}
bis.close();
bos.close();
}
三、DataInputStream/DataOutputStream
- DataInputStream：与DataOutputStream搭配使用，我们可以按照可移植方式从流读取到基本数据类型
- DataOutputStream：与DataInputStream搭配使用，我们可以按照可移植方式向流写入基本数据类型
构造器
DataInputStream dis = new DataInputStream(new FileInputStream(""));
DataOutputStream dos = new DataOutputStream(new FileOutputStream(""));
案例
- DataInputStream
public class DisDemo {
public static void main(String[] args) throws IOException {
String file = "";
DataInputStream dis = new DataInputStream(new FileInputStream(file));
int i = dis.readInt();
System.out.println(i);
i = dis.readInt();
System.out.println(i);
//读取文件中 long型、double型、和utf编码字符
long l = dis.readLong();
System.out.println(l);
double d = dis.readDouble();
System.out.println(d);
String s = dis.readUTF();
System.out.println(s);
dis.close();
}
}
- DataOutputStream
public class DosDemo {
public static void main(String[] args) throws IOException {
String file = "demo/dos.dat";
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
dos.writeInt(10);
dos.writeInt(-10);
dos.writeLong(12l);
dos.writeDouble(12.3);
dos.writeUTF("中国"); //采用UTF-8编码输出
dos.writeChars("中国"); //采用Java默认的 utf-16be编码输出
dos.close();
}
}
3、字符流
- ① 编码问题
- ② 认识 文本和文本文件
- Java文本：指的是char是16位无符号整数，是字符的Unicode编码（双字节编码）
- 文本：byte byte byte...的数据序列
- 文本文件是文本（char）序列按照某种编码方案（utf-8/gbk等）序列化为byte的存储结果
- ③ 字符流（Reader、Writer）：操作文本、文本文件
- 字符处理，一次处理一个字符
- 字符的底层依然是基本的字节序列
- 字符流的基本实现：
- InputStreamReader：完成byte流解析为char流，按照编码处理
- OutputStreamWriter：提供char流到byte流，按照编码处理
一、字符编码
分类
- ASCII（数字、英文）:1个字符占一个字节（所有的编码集都兼容ASCII）
- ISO8859-1（欧洲）：1个字符占一个字节
- GB-2312/GBK：1个字符占两个字节
- Unicode: 1个字符占两个字节（网络传输速度慢）
- UTF-8：变长字节，对于英文一个字节，对于汉字两个或三个字节。
原则
- 保证编解码方式的统一，才能不至于出现错误。
二、InputStreamReader/OutputStreamWriter
构造器
FileInputStream in = new FileInputStream("D:\\logs\\文本.txt");
InputStreamReader isr = new InputStreamReader(in,"gbk");//不写第二个参数，默认使用项目的编码格式
FileOutputStream out = new FileOutputStream("D:\\logs\\文本2.txt");
OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
案例
/**
*文件拷贝
*/
public class CharStreamDemo {
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("D:\\logs\\文本.txt");
InputStreamReader isr = new InputStreamReader(in,"gbk");//不写第二个参数，默认使用项目的编码格式
char[] buf = new char[8*1024];
int c;
FileOutputStream out = new FileOutputStream("D:\\logs\\文本2.txt");
OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
while ((c=isr.read(buf,0,buf.length))!=-1){
String s = new String(buf,0,c);
System.out.println(s);
osw.write(buf,0,c);
osw.flush();
}
isr.close();
osw.close();
}
}
三、BufferedReader/BufferedWriter/PrintWriter
BufferedWriter和PrintWriter作用相同，PrintWriter无须刷新，可自动识别换行
构造器
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\logs\\文本.txt"),"gbk"));
BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream("D:\\logs\\文本2.txt"),"utf-8"));
PrintWriter pw = new PrintWriter("D:\\logs\\文本3.txt");
案例
/**
*文件拷贝
*/
public class BrAndBwDemo {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\logs\\文本.txt"), "gbk"));
PrintWriter pw = new PrintWriter("D:\\logs\\文本3.txt");
String line;
while ((line = br.readLine()) != null) {
System.out.println(line); //一次读一行,不能识别换行
pw.println(line); //ln自动换行
pw.flush();
}
br.close();
pw.close();
}
}
四、说明
- io包的InputStreamReader：称为从字节流到字符流的桥转换类。这个类可以设定字符转换方式。
- OutputStreamWriter：字符到字节
BufferedReader有readLine()使得字符输入更加方便。 - 在I/O流中，所有输入方法都是阻塞方法。
- BufferedWriter：给输出字符加缓冲，因为它的方法很少，所以使用父类PrintWriter，它可以使用字节流对象，而且方法很多。
4、RandomAccessFile
- RandomAccessFile 是Java提供的对文件内容的访问，既可以读文件也可以写文件
- 没有继承InputStream/OutputStream抽象类
- 支持随机访问文件，可以访问文件的任意位置
- ①Java文件模型：在硬盘上的文件是byte byte byte存储的，是数据的集合
- ②打开文件：有两种模式 "rw"（读写） "r"(只读)
- RandomAccessFile raf = new RandomAccessFile(file,"rw");
- 文件指针：打开文件时指针在开头 pointer=0;
- ③写方法：raf.write(int) 只写一个字节（后8位），同时指针指向下一个位置，准备再次写入
- ④读方法：int b = raf.read(); 读一个字节
- ⑤文件读写完成之后一定要关闭
构造器
RandomAccessFile raf = new RandomAccessFile(new File(""),"rw");//读写模式
案例
public class RandomDemo {
public static void main(String[] args) throws IOException {
File demo = new File("demo");
if (!demo.exists()) {
demo.mkdir();
}
File file = new File(demo, "raf.dat");
if (!file.exists()) {
file.createNewFile();
}
RandomAccessFile raf = new RandomAccessFile(file, "rw");
System.out.println(raf.getFilePointer());//指针的位置
raf.write('A'); //只写了一个字节（后8位）
System.out.println(raf.getFilePointer());//指针的位置
raf.write('B');
int i = 0x7fffffff;
raf.writeInt(i);
System.out.println(raf.getFilePointer());//指针的位置
String s = "中";
byte[] gbk = s.getBytes("gbk");
raf.write(gbk);
System.out.println(raf.getFilePointer());//指针的位置
//读文件，把指针移到头部
raf.seek(0);
//一次性读取，把文件中的内容都读到字节数组中
byte[] buf = new byte[(int) raf.length()];
raf.read(buf);
System.out.println(Arrays.toString(buf));
for (byte b : buf) {
System.out.println(Integer.toHexString(b & 0xff) + ""); //16进制
}
raf.close();
}
}
