IO学习笔记整理
1. File类
1.1 File对象的三种创建方式：
File对象是一个抽象的概念，只有被创建出来之后，文件或文件夹才会真正存在
注意：File对象想要创建成功，它的目录必须存在！
import java.io.File; /*
演示三种创建File对象的方式
*/
public class FileDemo {
public static void main(String[] args) throws Exception {
//指定完整路径名的字符串
File f1 = new File("e:/test/a.txt");
//指定父路径名以及子路径名的字符串
File f2 = new File("e:/test", "b.txt");
//指定父路径的File对象以及子路径名的字符串
File f3 = new File(new File("e:/test"), "c.txt"); f1.createNewFile();
f2.createNewFile();
f3.createNewFile(); }
}
如果使用的是相对路径(即不以盘符开头)，那么默认的是当前项目的路径
1.2 mkdir和createNewFile方法
mkdir和createNewFile两个方法的区别，前者看成文件夹，哪怕写上了后缀，后者看成文件
import java.io.File; /*
演示mkdir和createNewFile的区别
注：如果出现同名的文件以及文件夹，File会首先创建文件！
*/
public class FileDemo2 {
public static void main(String[] args) throws Exception {
File file1 = new File("e:/test/a.txt");
File file2 = new File("e:/test/aaa.txt");
//创建一个文本文件
file1.createNewFile();
//创建一个名为aaa.txt的文件夹
file2.mkdir();
}
}
在调用delete方法的时候要注意要删除的文件夹不能包含内容，否则就会报错
1.3 renameTo方法
renameTo方法如果在不同路径，就相当于剪切加重命名
import java.io.File; /*
演示rename方法以及剪切的效果
*/
public class FileDemo3 {
public static void main(String[] args) {
File srcFile = new File("e:/test/a.txt");
File destFile = new File("e:/test/b.txt");
//如果源文件和目标文件拥有相同的父目录，那么就是改名操作
//srcFile.renameTo(destFile);
//如果两者的父目录不相同，那么就相当于剪切并改名
File destFile2 = new File("e:/test1/b.txt");
srcFile.renameTo(destFile2);
}
}
1.4 length方法的说明
关于length()方法，如果是文件的话返回文件的字节数，而如果是文件夹的话，是不确定的
import java.io.File; /*
关于length方法的说明
*/
public class FileDemo4 {
public static void main(String[] args) {
//如果是一个文件的话，length方法即返回这个文件的字节数
File f1 = new File("e:/test/a.txt");
System.out.println(f1.length());
//如果是文件夹的话，返回值是不确定的，不一定是0，有时会是别的数字
File f2 = new File("e:/test");
System.out.println(f2.length());
}
}
1.5 listFiles方法
listFiles方法的优点是由于返回的是一个File类型的数组，而File本身有各种各样的方法，因此非常灵活，可以实现各种操作
import java.io.File;
import java.io.FilenameFilter; /*
演示listFiles方法，实现找到一个文件夹下一级子目录的所有txt文件，并把文件名打印出来
*/
public class FileDemo5 {
public static void main(String[] args) {
//常规方法
File f = new File("e:/test");
File[] files = f.listFiles();
for (File file : files) {
if(file.getName().endsWith(".txt")){
System.out.println(file.getName());
}
}
System.out.println("<---------------------->");
//使用FileNameFilter过滤出a.txt这个文件
//采用匿名内部类方式
File[] files1 = f.listFiles(new FilenameFilter() {
public boolean accept(File dir, String name) {
return new File(dir,name).getName().equals("a.txt");
}
});
for (File file : files1) {
System.out.println(file.getName());
}
}
}
1.6 递归操作(查找以及删除)
递归地查找某一类文件
import java.io.File; /*
演示递归地查找jpg文件并将文件名打印出来
*/
public class FileRecursiveDemo1 {
public static void main(String[] args) {
findJPG(new File("e:"));
}
public static void findJPG(File file){
File[] files = file.listFiles();
for (File f : files) {
if(f.isDirectory()){
findJPG(f);
}
else{
if(f != null && f.getName().toUpperCase().endsWith("JPG")){
System.out.println(f.getName());
}
}
}
}
}
递归删除文件夹
import java.io.File; /*
演示递归删除文件夹以及文件夹下所有内容
*/
public class FileRecursiceDemo2 {
public static void main(String[] args) {
deleteDir(new File("e:/test"));
}
public static void deleteDir(File f){
File[] files = f.listFiles();
for (File file : files) {
if(file.isDirectory()){
deleteDir(file);
}else{
file.delete();
}
}
//文件都删除干净后，最后再把文件夹删除即可
f.delete();
}
}
2. 输入流和输出流
2.1 java IO框架中各种流的继承及实现图：
2.2 带异常处理的拷贝程序
基本思路：在try块中执行基本业务逻辑，catch中捕捉异常，记住使用Exception兜底，最后将关流操作放在finally中执行
import java.io.*; /*
演示带完整异常处理的文件拷贝程序
*/
public class CopyFileDemo {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
try {
br = new BufferedReader(new FileReader("e:/test/a.txt"));
bw = new BufferedWriter(new FileWriter("e:/test/b.txt"));
String line = null;
while((line = br.readLine()) != null){
bw.write(line);
bw.newLine();
}
} catch (FileNotFoundException e) {
System.out.println("File Not Found !!!");
} catch (IOException e){
System.out.println("IO Exception !!!");
} catch (Exception e){
System.out.println("Unknown Exception !!!");
}finally {
if(br != null){
try {
br.close();
} catch (IOException e) {
}
}
if(bw != null){
try {
bw.close();
} catch (IOException e) {
}
}
}
}
}
新版try-catch语句，可以将需要关闭的流使用try(){}形式放在小括号内，这样就不用再写finally块就能自动关流了
import java.io.*; /*
演示带完整异常处理的文件拷贝程序升级版
*/
public class CopyFileDemo2 {
public static void main(String[] args) {
try (
BufferedReader br = new BufferedReader(new FileReader("e:/test/a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("e:/test/b.txt"));
){
String line = null;
while((line = br.readLine()) != null){
bw.write(line);
bw.newLine(); }
} catch (FileNotFoundException e) {
System.out.println("File Not Found !!!");
} catch (IOException e){
System.out.println("IO Exception !!!");
} catch (Exception e){
System.out.println("Unknown Exception");
}
}
}
2.3 三种方式触发流的关闭
import java.io.BufferedOutputStream;
import java.io.FileOutputStream; /*
演示三种方式触发流的关闭
*/
public class StreamCloseDemo {
public static void main(String[] args) throws Exception {
//test1();
//test2();
test3();
} public static void test1() throws Exception {
//使用close方法关闭流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/test/a.txt"));
bos.write("hello world".getBytes());
bos.close();
}
public static void test2() throws Exception{
//手动刷新
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/test/a.txt"));
bos.write("hello world".getBytes());
bos.flush();
}
public static void test3() throws Exception{
//当写出的字节数大于等于8192的时候，就会自动触发关流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("e:/test/a.txt"));
bos.write(new byte[8192]);
}
}
对于第三种方式，对比图如下：
当写出的字节数为8191的时候，文件字节大小为0字节，说明并未关流
而当写出字节数为8192的时候，文件字节正好为8KB，说明写出成功！
2.4 数据流
由于后期在用到hadoop中的时候会涉及到ComparableWritable接口的重写方面的知识，因此这里需要关注，特别关注writeInt方法的底层实现！可以查看这些方法的底层源码！
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream; /*
演示数据流的基本方法：
1.数据流具有丰富的API可以读写各种各样的数据类型而不用每次都调用getBytes()方法
2.注意，若用数据流将数据写出到文本文件，则会出现乱码，解决方案是再用read方法读回来
*/
public class DataInputOutputStreamDemo {
public static void main(String[] args) throws Exception {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("e:/test/a.txt"));
dos.writeBoolean(true);
dos.writeByte(97);
dos.writeChar('b');
dos.writeInt(10);
dos.writeDouble(3.14);
dos.writeUTF("hello world");
//然后用相对应的方法读回来
DataInputStream dis = new DataInputStream(new FileInputStream("e:/test/a.txt"));
System.out.println(dis.readBoolean());
System.out.println(dis.readByte());
System.out.println(dis.readChar());
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readUTF());
}
}
WriteInt和ReadInt的源码分析：
// writeInt
public final void writeInt(int v) throws IOException {
out.write((v >>> 24) & 0xFF);
out.write((v >>> 16) & 0xFF);
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
incCount(4);
}
查看了writeInt方法的实现原理，可知，它底层是通过将一个int类型的数据通过无符号右移操作从高位到低位一个一个拿出8位来实现的，而与0xFF进行与运算则保证了，除了这8位，其他位全部都是0，而readInt()方法则正好相反，将所有的获得的4个数字再进行左移操作，再加到一起去即可，具体代码如下：
public final int readInt() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0));
}
知道了底层原理之后，自己也可以写字节数组和int值相互转换的方法：
/*
写两个将字节数组与int值相互转换的方法
*/
public class MyUtils { public static void main(String[] args) {
//进行测试
int b = -256;
byte[] bytes = int2Bytes(b);
System.out.println(bytes2Int(bytes));
} public static byte[] int2Bytes(int i){
byte[] bytes = new byte[4];
bytes[0] = (byte) (i >> 24);
bytes[1] = (byte) (i >> 16);
bytes[2] = (byte) (i >> 8);
bytes[3] = (byte) (i >> 0);
return bytes;
} public static int bytes2Int(byte[] bytes){
int i1 = bytes[0] & 0xFF << 24;
int i2 = bytes[1] & 0xFF << 16;
int i3 = bytes[2] & 0xFF << 8;
int i4 = bytes[3] & 0xFF << 0;
return i1 + i2 + i3 + i4;
}
}
2.5 打印流
打印流是单向的，只有输出方法，没有读取方法，但是有其特殊的打印方法，并且经过设置可以实现自动关流
import java.io.FileOutputStream;
import java.io.PrintWriter; /*
演示打印流的基本操作
*/
public class PrintWriterDemo {
public static void main(String[] args) throws Exception {
//设置成可以自动关流的那种，根据文档可知，自动关流只对println等方法有效
PrintWriter pw = new PrintWriter(new FileOutputStream("e:/test/a.txt"),true);
//使用自带的特殊方法
pw.println(10);
pw.println(3.14);
pw.println("hello world");
}
}
2.6 内存流
本质上不涉及到文件的IO，是用数组来实现的，写的时候会写出到一个无名的数组，当调用toByteArray方法时可以返回字节数组
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream; /*
演示内存流的基本方法
*/
public class ByteArrayInputOutputStreamDemo {
public static void main(String[] args) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write("hello world".getBytes());
byte[] bytes = baos.toByteArray();
System.out.println(new String(bytes));
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
int len = 0;
byte[] buf = new byte[1024];
len = bais.read(buf);
System.out.println(new String(buf,0,len)); }
}
2.7 RandomAccessFile(随机访问文件)
import java.io.RandomAccessFile; /*
演示随机访问文件类：
1.该类相当于是一个巨大的byte数组，即可以读文件又可以写文件
2.具有seek方法可以随便移动指针
3.有只读模式以及正常模式
*/
public class RandomAccessFileDemo {
public static void main(String[] args) throws Exception {
//指定的模式使得它既可以读，又可以写
RandomAccessFile raf = new RandomAccessFile("e:/test/a.txt", "rw");
raf.writeByte(98);
raf.writeLong(100L);
raf.writeUTF("hello world");
//试验：将指针移动至第9个字节处，查看是否可以读到hello world字符串
raf.seek(9L);
System.out.println(raf.readUTF());
}
}
2.8 Properties类(配置文件)
此类并不是IO，但是和IO关系很紧密，查看源码可知它是继承自HashTable的，因此可以把它当成map使用
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties; /*
演示一个简单的配置文件的读取以及更新等操作
*/
public class PropertiesDemo {
public static void main(String[] args) throws Exception {
//先用一个输入流读取已经存在了的配置文件
FileInputStream fis = new FileInputStream("e:/test/prop.txt");
Properties prop = new Properties();
prop.load(fis);
System.out.println(prop.getProperty("name"));
//进行更新操作，如果不存在，那就是添加
prop.setProperty("id","0001");
//更新的内容还是输出到原来文件中去
//如果不想写上comments的话，可以写null，但是绝对不可以出现中文，否则就会出现乱码
prop.store(new FileOutputStream("e:/test/prop.txt"),null);
}
}
2.9 对象输出 / 输入流 (ObjectOutputStream / ObjectInputStream)
对象输出流使得对象，这样一个具有立体结构类型的数据能够永久化地保存在磁盘上去，(这一过程就叫做持久化，在之后的大数据学习过程中会反复接触到)，这样就使得对象可以脱离程序而存在，该过程就叫做“序列化”，而"反序列化“则正好相反，将一个已经保存在磁盘上的对象再反过来读到内存中
想要序列化一个对象，必须具备这样一个前提，那就是该对象要实现Serializable接口，该接口十分特殊，方法体内没有任何代码，是一个标记性接口，相当于在告诉用户，如果对象要想序列化，就得实现这个接口，不实现它，那就不能用！
public interface Serializable {
}
判断末尾的方法：之前的都要一个结束符，-1或是null，而Object却没有，因此，判断结束条件的方法不一样
需要注意的是：对象流和之前接触到的流判断是否达到文件末尾的方法不一样，由于对象流在写出到文件时，并不会在末尾添加-1或null这样的结束符，因此通过原来的方式判断是否达到文件末尾将不再适用，会抛出EOFException，解决方案是将所有的对象全部放在一个集合中，在反序列化时一次性读取整个集合即可，演示代码如下所示：
/*
演示对象流
演示解决EOFException的方案
*/ import java.io.*;
import java.util.ArrayList; class Employee implements Serializable {
private int id;
private String name; public Employee() {
} public Employee(int id, String name) {
this.id = id;
this.name = name;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} @Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
} public class ObjectStreamDemo {
public static void main(String[] args) throws Exception {
//serialize();
deSerialize();
}
//序列化方法
public static void serialize() throws Exception {
//创建100个员工对象将它们放到集合中并持久化保存起来
ArrayList<Object> list = new ArrayList<>();
for(int i = 1; i <= 100; i++){
Employee emp = new Employee();
emp.setId(i);
emp.setName("tom" + i);
list.add(emp);
}
//对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:/test/oos.txt"));
//使用该输出流特有的方法writeObject()
oos.writeObject(list);
oos.close();
}
//反序列化方法
public static void deSerialize() throws Exception{
//一次性读取一整个集合，这样就避免了EOFException异常的问题
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:/test/oos.txt"));
Object obj = ois.readObject();
ArrayList<Object> list = (ArrayList<Object>) obj;
for (Object o : list) {
System.out.println((Employee) o);
}
}
}
3. IO的应用
3.1 切割小文件 & 合并小文件
/**
* 给定需要进行切割的大文件的文件路径，需要存放小文件的目标文件夹，以及每个小文件的大小
*
* @param srcFilePath 源文件的路径
* @param destDir 目标文件夹
* @param size 每个小文件的大小
*/
public static void splitFile(String srcFilePath, String destDir, long size){
//先进行判断，只有源文件的大小大于等于小文件大小时，才进行切割
File srcFile = new File(srcFilePath);
long srcFileLen = srcFile.length();
if(srcFileLen < size){
System.out.println("Small file's size is larger than source file's size!");
}else{
//判断能够把文件切割成几份
int count = (int) (srcFileLen % size == 0 ? srcFileLen / size : srcFileLen / size + 1);
//遍历count变量，如果是最后一个小文件的话，重新计算文件长度
long len = size;
for(int i = 0; i < count; i++){
if(srcFileLen % size != 0 && i == count - 1){
len = srcFileLen % size;
}
copyFile(srcFile,destDir,i,i * size,len);
}
}
} /**
* 将切割好的文件进行合并，合并到另一个目录下
*
* @param srcDir 源文件夹
* @param destDir 目标文件夹
*/
public static void mergeFile(String srcFilePath, String srcDir, String destDir){
String srcFileName = new File(srcFilePath).getName();
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new File(destDir,srcFileName));
File[] files = new File(srcDir).listFiles();
for (File file : files) {
FileInputStream fis = new FileInputStream(file);
byte[] buf = new byte[1024 * 8];
int len = 0;
while((len = fis.read(buf)) != -1){
fos.write(buf,0,len);
}
fis.close();
} } catch (FileNotFoundException e) {
System.out.println("File Not Found!");
} catch (Exception e){
System.out.println("Unknown Exception!");
} finally {
if(fos != null){
try {
fos.close();
} catch (IOException e) {
}
}
}
} /**
*
* 单独将拷贝文件方法抽取出来
*
* @param srcFile 源文件
* @param destDir 目标文件夹
* @param i 小文件索引
* @param offset 被切割文件的偏移量，即从哪个字节开始切割
* @param len 需要拷贝的小文件的长度
*/
public static void copyFile(File srcFile, String destDir, int i, long offset, long len){
RandomAccessFile raf = null;
FileOutputStream fos = null;
try {
raf = new RandomAccessFile(srcFile,"rw");
raf.seek(offset);
byte[] buf = new byte[(int) len];
//一次性把数组读满
raf.read(buf);
fos = new FileOutputStream(new File(destDir, srcFile.getName() + "_" + i));
fos.write(buf); } catch (FileNotFoundException e) {
System.out.println("File Not Found!");
} catch (Exception e){
System.out.println("Unknown Exception!");
} finally {
if(raf != null){
try {
raf.close();
} catch (IOException e) {
}
}
if(fos != null){
try {
fos.close();
} catch (IOException e) {
}
}
}
}
}
3.2 归档文件 & 解档文件
简单说明：文件归档过后若想要解档，则必须要知道文件名是什么，以及文件长度是多少，因此，在进行归档操作时，必须写入这些控制字符，然后在解档时先对这些控制字符进行解析，解析完之后才能真正地进行文件的写出
/**
* 指定源文件夹，将文件夹下的所有文件夹归档至目标文件夹去
*
* @param srcDir 源文件夹
* @param destDir 目标文件夹
*/
public static void archiveFile(String srcDir, String destDir){
FileOutputStream fos = null;
try {
fos = new FileOutputStream(new File(destDir, "archive.dat"));
//列出这个文件夹下的文件
File[] files = new File(srcDir).listFiles();
for (File file : files) {
if(file.isFile()){
//先写文件名的长度，一个字节存放足够
int fileNameLen = file.getName().length();
fos.write(fileNameLen);
//然后写真实的文件名
fos.write(file.getName().getBytes());
//写四个字节的文件内容长度，自己手写一个工具类
fos.write(int2Bytes((int) file.length()));
//开始正式拷贝真实的文件
FileInputStream fis = new FileInputStream(file);
byte[] buf = new byte[1024 * 8];
int len = 0;
while((len = fis.read(buf)) != -1){
fos.write(buf,0,len);
}
fis.close();
}
}
} catch (FileNotFoundException e) {
System.out.println("File Not Found!");
} catch (Exception e){
System.out.println("Unknown Exception!");
} finally {
//关闭资源
if(fos != null){
try {
fos.close();
} catch (IOException e) {
}
}
}
} /**
* 将归好档的文件进行解档操作至目标文件夹中去
*
* @param srcDir 已经归好档的文件所在的文件夹
* @param destDir 需要解档到的目标文件夹
*
*/
public static void unarchiveFile(String srcDir, String destDir) {
FileInputStream fis = null;
try {
fis = new FileInputStream(new File(srcDir,"archive.dat"));
//先用read方法读一个字节读出文件名长度的字节
int b = 0;
while((b = fis.read()) != -1){
byte[] fileNameBytes = new byte[b];
//读取b长度字节数的文件名数组
fis.read(fileNameBytes);
//解析出文件名
String fileName = new String(fileNameBytes);
//读取4个字节的byte数组并将其还原回int值表示文件的真实长度
byte[] fileLenBytes = new byte[4];
fis.read(fileLenBytes);
int fileLen = bytes2Int(fileLenBytes);
//读取fileLen长度的文件真实数据
byte[] fileBytes = new byte[fileLen];
fis.read(fileBytes);
FileOutputStream fos = new FileOutputStream(new File(destDir, fileName));
fos.write(fileBytes);
fos.close();
}
} catch (FileNotFoundException e) {
//System.out.println("File Not Found!");
} catch (Exception e){
System.out.println("Unknown Exception!");
} finally {
if(fis != null){
try {
fis.close();
} catch (IOException e) {
}
}
}
} /**
* 将一个整型数转换成字节数组
*
* @param i 传入的int值
*/
public static byte[] int2Bytes(int i){
byte[] bytes = new byte[4];
bytes[0] = (byte) (i >> 24);
bytes[1] = (byte) (i >> 16);
bytes[2] = (byte) (i >> 8);
bytes[3] = (byte) (i >> 0);
return bytes;
} /**
* 将一个字节数组还原成int值
*
* @param bytes 长度为4的字节数组
*
*/
public static int bytes2Int(byte[] bytes){
int i1 = (bytes[0] & 255) << 24;
int i2 = (bytes[1] & 255) << 16;
int i3 = (bytes[2] & 255) << 8;
int i4 = (bytes[3] & 255) << 0;
return i1 + i2 + i3 + i4;
}
