一、简介
1.文件的概念：数据在磁盘的唯一最小描述，上层应用程序必须通过文件来操作磁盘上的数据
注：Java中的File不是真实文件
网络下载的数据（文本 图片 视频 音频）写入缓存，读取缓存中的数据需要流来实现
2.读写文件的步骤一般为
（1）创建文件、创建目录（文件夹）
（2）判断文件是不是存在（判断目录是否存在）
（3）写入数据
（4）删除文件、删除目录
3.写入、读取数据
Java中的File是没有具体读取和写入的方法，需要通过输入输出流来操作
输出流：内存-外部（硬盘，网络，设备）
输入流：外部-内存
4.数据的存储有两种
（1）字节形式：图片，音频，视频，exe，这些是以二进制形式存储的
（2）字符形式：文本
所以读取方式有所不同
字节形式用字节流，一次读取一个字节，InputStream/OutputStream
字符形式用字符流，一次读取一个字符（两个字节）Reader/Writer
输入输出流都是抽象类，所以我们需要使用输入输出流的具体实现类
字节输入输出流：FileInputStream/FileOutputStream
字符输入输出流：FileReader/FileWriter
二、字节流
类1——创建一个文件
class creatFile {
public static void creatFile() {
//关键字File,让file指向一个对应文件，需要文件名
//new File并不会自动创建文件
File file = new File("C:\\Users\\Administrator\\Desktop\\1.text");
//判断文件或者目录是否存在
if (!file.exists()) {
//3.创建文件，捕获异常
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
类2——创建一个目录
class creatDir {
public static void creatDir() {
File file = new File("C:\\Users\\Administrator\\Desktop\\", "file");
if (!file.exists()) {
try {
file.mkdir();
} catch (NullPointerException e) {
e.printStackTrace();
}
}
}
}
类3——删除文件
class deleteFile {
File file = new File("C:\\Users\\Administrator\\Desktop\\", "1.text");
public void deleteFile() {
if (file.exists()) {
file.delete();
}
}
}
类4——判断是文件还是目录
class FileOperation {
File file = new File("C:\\Users\\Administrator\\Desktop\\代码");
public void operation() {
if (file.isFile()) {
System.out.println("是文件");
}
if (file.isDirectory()) {
System.out.println("是目录");
}
}
}
类5——查看当前文件的所有内容
class List {
File file = new File("C:\\Users\\Administrator\\Desktop\\", "1.text");
String[] fileNameList = file.list();
public void List() {
for (String name : fileNameList) {
System.out.print(name);//输出所有列表的名称
}
}
}
类6——过滤文件（按要求筛选文件）
class Choose {
File file = new File("C:\\Users\\Administrator\\Desktop\\", "1.text");
public void choose() {
String[] chooseNameList = file.list(new FilenameFilter() {
//筛选文件需要实现FilenameFilter类，这里使用匿名内部类减少代码量
@Override
public boolean accept(File dir, String name) {
//如果返回true，当前文件会被选中
//如果返回false，当前文件会被过滤掉
File f = new File(dir, name);
if (f.isDirectory()) {
return true;
}
return false;
}
});
}
}
类7——写入数据
class Write {
String des = "C:\\Users\\Administrator\\Desktop\\";
public static void WriteToFile(String des) {
//1.准备数据
String text = "Hello World";
FileWriter fw = null;
//2.判断是需要字符流还是字节流
try {
//3.写入数据
fw = new FileWriter(des);
fw.write(text);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
类8——复制字节型文件
class CopyChar {
public static void CopyImageToFile(String src, String des) {
//1.将图片读取到内存中
//字节输入流FileInputStream
//2.将内存中的数据写入到磁盘中
//字节流 输出流 FileOutputStream
//凡是实现了closeable接口的类，都可以在try（）括号内部创建对象
//当try代码块执行完毕或者有异常，系统自动close
try (FileInputStream inf = new FileInputStream(src);
FileOutputStream outf = new FileOutputStream(des)) {
int b;
//byte[] bytes = new byte[1024];操作一个字节数组，解决read（）效率低的问题
while (true) {
b = inf.read();
//read();方法是一个一个字节的读，当文件较大时，效率就会非常低
//b = inf.read(byte);
if (b == -1) {
break;
}//当读取完毕后返回值默认为-1,操作字节数组时是一样的
outf.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
类9——复制字符型文件
class CopyText {
public static void CopyTextToFile(String src, String des) {
//复制字符和复制字节方法是完全一样的，只是关键字不一样
try (FileReader inf = new FileReader(src);
FileWriter outf = new FileWriter(des)) {
int b;
//byte[] bytes = new byte[1024];操作一个字符数组
while (true) {
b = inf.read();
//b = inf.read(byte);
if (b == -1) {
break;
}
outf.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、处理流——缓冲流
缓冲输入流BufferedInputStream BufferedReader
缓冲输出流BufferedOutputStream BufferedWriter
虽然使用了处理流比较快，但是真正读取数据的是节点流
1.必须先创建节点流对象,将数据从磁盘读到内存缓冲区
2.将内存缓冲区的数据读到处理流对应的缓冲区
3.从处理流的缓冲区将数据读取到对应的地方
输入输出重定向——打印流（PrintStream）指定输入输出的位置（默认是输出到终端）
类1——用处理流复制字节
class BufferChar{
public void Operation(String scr,String des){
BufferedOutputStream bos = null;
try {
//创建缓冲输入流
FileInputStream fis = new FileInputStream(scr);
BufferedInputStream bis = new BufferedInputStream(fis);
//创建缓冲输出流
FileOutputStream fos = new FileOutputStream(des);
bos = new BufferedOutputStream(fos);
int b;
while((b = bis.read())!= -1){
bos.write(b);
}
bos.flush();
}catch (Exception e){
e.printStackTrace();
}finally {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
类2——用处理流复制字符
class BufferText{
public void Operation(String scr,String des){
BufferedWriter bw = null;
try{
//创建输入流
FileInputStream fis = new FileInputStream(scr);
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
//创建输出流
FileOutputStream fos = new FileOutputStream(des);
OutputStreamWriter osw = new OutputStreamWriter(fos);
bw = new BufferedWriter(osw);
int b;
while((b = br.read())!= -1){
bw.write(b);
}
bw.flush();//当使用处理读取和输出时，需要调用flush()来刷新数据流
}catch (Exception e){
e.printStackTrace();
}finally {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
类3——重定向输入输出——在指定位置输出、在指定位置输入
class ReDirection{
public void redirection_out(String des){
FileOutputStream fos = null;
try {
fos = new FileOutputStream(des);
PrintStream ps = new PrintStream(fos);//重定向输出,在指定位置输出
System.setOut(ps);
System.out.println("Hello World");
}catch (Exception e){
e.printStackTrace();
}finally {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void redirection_in(String src){
FileInputStream fis = null;
try {
fis = new FileInputStream(src);
Scanner scanner = new Scanner(fis);//重定向输入，在指定位置输入
while (scanner.hasNext()){
//把所有行的内容显示出来（默认只输出一行，所以写循环）
System.out.println(scanner.next());
}
}catch (Exception e){
e.printStackTrace();
}finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
四、对象处理
把一个对象通过文件的方式存储和读取
class Save_Read_Object{
class Person implements Serializable{
int age;
String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
}
public void saveobject(String des) {
try {
FileOutputStream fos = new FileOutputStream(des);
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person p = new Person(18,"Jack");
oos.writeObject(p);
}catch (Exception e){
e.printStackTrace();
}
}//将对象保存在指定文件里面
public void readobject(String src){
try{
FileInputStream fis = new FileInputStream(src);
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
}catch (Exception e){
e.printStackTrace();
}
}//从指定文件里面读取对象
}
五、RandomAccessFile类
当一个文件存在的时候，写入数据时会把原来的文件覆盖掉
如果不想发生此情况，需要使用RandomAccessFile
class RandromAccess{
public void randomaccess(String src){
try {
RandomAccessFile raf = new RandomAccessFile(src,"rw");
//有几种模式mode：r,rw,rws
//r为只读，rw为可读写，rws为同时读写
}catch (Exception e){
e.printStackTrace();
}
}
}
