2021-01-14

File文件操作

1、File类常用方法（查看API）

1）、创建文件/文件夹：

boolean createNewFile(); //创建文件
boolean mkdir();创建文件夹
boolean mkdirs();创建多级文件夹。

2）、删除文件：

boolean delete();
void deleteOnExit();在程序退出时删除文件

3）、获得文件信息：

getName();
getPath();
getParent()

list()：返回目录下的所有文件和目录名，即String[]数组
listFiles()：返回目录下的所有文件和目录，即File[]数组

4）、判断

boolean exists(); 文件是否存在。
isFile();文件
isDirectory();文件夹

2、综合代码

public class FileDemo {
	// 创建文件
	public void create(File file) {
		if (!file.exists()) {// 只有当文件不存在时才能创建文件
			try {
				file.createNewFile();// createNewFile()只能创建文件，不能创建文件夹
				System.out.println("文件已经创建！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		} else {
			System.out.println("该文件已存在！");
		}
	}

	// 查看文件相关信息
	public void showFileInfo(File file) {
		if (file.exists()) {
			// 当文件存在查看信息
			if (file.isFile()) {
				System.out.println("该文件名为：" + file.getName());
				System.out.println("相对路径为：" + file.getPath());
				System.out.println("绝对路径为：" + file.getAbsolutePath());
				System.out.println("文件长度为：" + file.length() + "字节");

			} else if (file.isDirectory()) {
				System.out.println("此文件为目录");
				/*
				 * list查看目录下所有文件和文件夹
				 */
				int count = 0;
				String[] list = file.list();
				for (String str : list) {
					if (str.endsWith(".docx")) {
						count++;
					}
				}
				System.out.println("该目录下共有" + count + "个word文档");
			}
		} else {
			System.out.println("文件不存在");
		}
	}

	// 删除文件
	public void delete(File file) {
		if (file.exists()) {// 只有当文件存在时才能删除
			file.delete();
			System.out.println("文件已经删除！");
		} else {
			System.out.println("文件不存在");
		}
	}

	public static void main(String[] args) {
		FileDemo fileDemo = new FileDemo();
		// File file = new File("F:/FileDemo/test.txt");
		// fileDemo.create(file);
		// fileDemo.showFileInfo(file);
		// fileDemo.delete(file);

		File dictory = new File("F:/数据备份");
		fileDemo.showFileInfo(dictory);
	}
}

IO流

流：有能力输出数据的数据源对象或者是有能力接收数据的接收端对象。本质：为数据源和目的地建立一个输送通道。

IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输、上传文件和下载文件，Java用于操作流的对象都在IO包中。

1、IO流的分类

按照流的方向分为输入、输出流；按照处理数据单位分为字节流、字符流。
图片参考

2、字节流

2.1、对文本文件

1）InputStream和OutputStream字节流基类：

abstract int read()：从输入流中读取数据的下一个字节
int read(byte[] b)：从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int read(byte[] b, int off, int len) ： 将输入流中最多 len 个数据字节读入 byte 数组

void write(byte[] b) :将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b, int off, int len): 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
abstract void write(int b): 将指定的字节写入此输出流
void flush():刷新此输出流并强制写出所有缓冲的输出字节

close():关闭输入/输出流

2）FileInputStream和FileOutputStream字节文件操作流

public static void main(String[] args) {
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("F:/FileDemo/test.txt");
			System.out.println("可读取字节数目" + fis.available());

			// read（）方法一个字节一个字节读
			int data; // 返回每个字节整数形式
			while ((data = fis.read()) != -1) {
				System.out.print((char) data);// 强转，能够看懂
			}

			System.out.println("******************************");
			// read（byte[] b）方法
			byte b[] = new byte[1024];
			int value;// 返回读取字节数
			while ((value = fis.read(b)) != -1) {
				for (int i = 0; i < value; i++) {
					System.out.print((char) b[i]);
				}
			}

		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {

			e.printStackTrace();
		} finally {
			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}


public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("F:/FileDemo/test.txt");
			String str = "完美世界-石昊";
			byte words[] = str.getBytes();// getBytes()字符串-》字节数组
			fos.write(words, 0, words.length);
			System.out.println("文件已经更新");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}


//文件复制
public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("F:/a.txt");
			fos = new FileOutputStream("F:/FileDemo/test.txt", true);// 追加内容

			byte words[] = new byte[1024];
			int data = -1;//字节读取个数
			while ((data = fis.read(words)) != -1) {
				fos.write(words);
			}
			System.out.println("文件复制完成！！！");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

3）BufferedInputStream和BufferedOutputStream字节缓冲流

 InputStream in = new FileInputStream("test.txt");
 // 字节缓存流
 BufferedInputStream bis = new BufferedInputStream(in);
 byte[] bs = new byte[20];
 int len = 0;
 while ((len = bis.read(bs)) != -1) {
     System.out.print(new String(bs, 0, len));   
 }
 // 关闭流
bis.close();

2.2、对二进制文件

DataInputStream和DataOutputStream：

DataInputStream dis = new DataInputStream(InputStream in);
对图片、音频、视屏等二进制文件读写。

//图片复制
public static void main(String[] args) {
		// 输入流
		DataInputStream dis = null;
		FileInputStream fis = null;

		// 输出流
		DataOutputStream dos = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("F:\\FileDemo\\Java基础语法.png");
			dis = new DataInputStream(fis);

			fos = new FileOutputStream("F:\\FileDemo\\BinaryFile\\new.png");
			dos = new DataOutputStream(fos);

			int temp;// 一个字节一个字节读
			while ((temp = dis.read()) != -1) {
				dos.write(temp);// 一个字节一个字节写
			}

			System.out.println("复制成功");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				dos.close();
				fos.close();

				dis.close();
				fis.close();

			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

2.3、序列化和反序列化

定义：将保存在内存中的对象数据转化为二进制数据流进行传输，任何对象都可以序列化。反序列化就是将二进制数据换回原对象。

Java中通过ObjectOutputStream对象+writeObject（）方法实现序列化。
ObjectInputStream对象+readObject（）实现反序列化。

注意：如果要实现序列化，则对象类必须实现Serializable接口，但是如果该类有属性不想被序列化则加上transient关键字。

public class Student implements Serializable {
	private String name;
	private int age;
	private String gender;
	private transient String password;// 加上transient信息不被序列化
	//构造方法、setter/getter省略
}

public class SeriasStuDemo {
	public static void main(String[] args) {
		Student stu = new Student("Jack", 18, "男", "123456");
		// 对象输出流
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		// 对象输入流
		ObjectInputStream ois = null;
		FileInputStream fis = null;

		try {
			System.out.println("下面开始序列化-----");
			fos = new FileOutputStream("F:\\FileDemo\\BinaryFile\\student.txt");
			oos = new ObjectOutputStream(fos);
			oos.writeObject(stu);
			System.out.println("序列化成功！");

			System.out.println("下面开始反序列化");
			fis = new FileInputStream("F:\\FileDemo\\BinaryFile\\student.txt");
			ois = new ObjectInputStream(fis);
			Student stu1 = (Student) ois.readObject();
			System.out.println("反序列化后信息:" + stu1.toString());

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}
}

3、字符流（针对中文）

Reader是所有输入字符流的父类，是一个抽象类。

FileReader------>InputStreamReader----->BufferedReader
因为FileReader不能设置编码格式，故多数情况还是使用InputStreamReader。

InputStreamReader reader = new InputStreamReader（InputStream（
						通常为FileInputStream），“指定编码格式”）
reader.read（）

public static void main(String[] args) {
		java.io.InputStreamReader reader = null;
		FileInputStream fis = null;

		try {
			fis = new FileInputStream("F:/FileDemo/novel.txt");
			reader = new java.io.InputStreamReader(fis, "GBK");// 指定编码格式

			char words[] = new char[1024];
			int len = -1;
			StringBuffer sb = new StringBuffer();
			while ((len = reader.read(words)) != -1) {
				sb.append(words);
			}
			System.out.println(sb);

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				reader.close();
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

BufferedReader reader = new BufferedReader（Reader，通常传
									入InputStreamReader）
reader.readLine()：按行读取



public static void main(String[] args) {
		FileInputStream fis = null;
		InputStreamReader fr = null;
		BufferedReader br = null;

		try {
			fis = new FileInputStream("F:\\FileDemo\\novel.txt");
			fr = new InputStreamReader(fis, "GBK");
			br = new BufferedReader(fr);

			String line = null;
			while ((line = br.readLine()) != null) {
				System.out.println(line);
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
				fr.close();
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

Writer是所有输出字符流的父类，同样是一个抽象类。

4、字节流和字符流的区别：

字节流一般用来处理图像，视频，以及PPT，Word类型的文件。字符流一般用于处理纯文本类型的文件，如TXT文件等，字节流可以用来处理纯文本文件，但是字符流不能用于处理图像视频等非文本类型的文件。只要是处理纯文本数据，就优先考虑使用字符流。除此之外都使用字节流。