Java-19 文件操作

1.File及构造方法

FIle类的概述：文件和目录路径的抽象表示形式。

构造方法：

public File(String pathname)
public File(String oarent,String child)
public File(File parent,String child)

示例

import java.io.File;

public class FileDemo1 {
	public static void main(String[] args) {
		// 方式1：
		File f1 = new File("J:\java大数据\java基础\day16\fileDemo\123.txt");
		// 方式2
		File f2 = new File("J:\java大数据\java基础\day16", "fileDemo\123.txt");
		// 方式3
		File f3 = new File("J:\java大数据\java基础\\day16");
		File f4 = new File(f3, "fileDemo\123.txt");
	}
}

2.File创建删除重命名

方法

public boolean createNewFile()   创建文件
public boolean mkdir()           创建单层文件夹
public boolean mkdirs()			创建多层文件夹
public boolean delete()          删除文件或文件夹
public boolean renameTo(File desc) 文件重命名
public boolean isDirectory()     判断是否是文件夹
public boolean isFile()			判断是否是文件
public boolean exists()			是否存在
public boolean canRead()		是否可读
public boolean canWrite()		是否可写
public boolean isHidden()		是否隐藏

创建文件

import java.io.File;
import java.io.IOException;

public class FileDemo2 {
	public static void main(String[] args) {
		// 创建文件时，要保证文件夹必须存在的
		File f1 = new File("J:\java大数据\java基础\day16\fileDemo\123.txt");
		try {
			System.out.println(f1.createNewFile());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

创建单层文件夹

File f2 = new File("J:\java大数据\java基础\day16\fileDemo2");
f2.mkdir();

创建多层文件夹

File f2 = new File("J:\java大数据\java基础\day16\fileDemo2");
f2.mkdirs();

删除（文件夹中有文件无法删除）

File f2 = new File("J:\java大数据\java基础\day16\fileDemo2");
f2.delete();

文件重命名(其实相当于文件移动)

File f1 = new File("J:\java大数据\java基础\day16\fileDemo\123.txt");
f1.renameTo(new File("J:\java大数据\java基础\day16\fileDemo\abc.txt"));

3.文件获取功能

public String getAbsolutePath()	获取绝对路径
public String getPath()	获取相对路径
public String getName() 获取文件名
public long length()	获取文件字节数
public long lastMondified() 最后修改时间(毫秒)

示例

import java.io.File;
import java.io.IOException;
import java.sql.Date;
import java.text.SimpleDateFormat;

public class FileDemo3 {
	public static void main(String[] args) throws IOException {
		File f = new File("J:\java大数据\java基础\day16\fileDemo\abc.txt");
		File f2 = new File("cba.txt"); // 相对路径：eclipse默认工作空间
		f2.createNewFile();
		// 绝对路径
		System.out.println(f.getAbsolutePath());
		System.out.println(f2.getAbsolutePath());
		// 相对路径
		System.out.println(f.getPath());
		System.out.println(f2.getPath());
		// 文件名
		System.out.println(f.getName());
		// 文件字节数
		System.out.println(f.length());
		// 最后修改时间
		System.out.println(f.lastModified());
		Date d = new Date(f.lastModified());
		String str = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(d);
		System.out.println(str);
	}
}

4.File中其他用法

public String[] list()	获取所有子文件名称
public File[] listFiles()	获取所有子文件对象

示例

import java.io.File;

public class FileDemo4 {
	public static void main(String[] args) {
		File f = new File("d:/");
		String[] arr = f.list();
		for (String s : arr) {
			// 打印所有子文件名称
			System.out.println(s);
		}
		File[] listFile = f.listFiles();
		for (File file : listFile) {
			// 打印所有子文件路径
			System.out.println(file.getAbsolutePath());
			// 打印所有子文件长度
			System.out.println(file.length());
		}
	}
}

打印一个文件夹所有.jpg文件

import java.io.File;

public class FileDemo5 {
	public static void main(String[] args) {
		findFiles("D:\meinvimg", ".jpg");
	}
	public static void findFiles(String path, String suffix) {
		// 1.把路径封装成文件
		File f = new File(path);
		// 2.得到所有子文件
		File[] listFiles = f.listFiles();
		// 3.遍历数组，判断每一文件是否是指定后缀结尾
		for (File file : listFiles) {
			String name = file.getName();
			if (name.toLowerCase().endsWith(suffix.toLowerCase()) & file.isFile()) {
				System.out.println(file.getAbsolutePath());
			}
		}
	}
}

5.文件过滤器

File[] listFiles(FilenameFilter filter)


import java.io.File;
import java.io.FilenameFilter;


public class FileDemo6 {
	public static void main(String[] args) {
		findFiles("D:\meinvimg", ".jpg");
	}
	public static void findFiles(String path, String suffix) {
		// 1.把路径封装成文件
		File f = new File(path);
		// 通过过滤器得到子文件
		// 接口通过匿名函数实现方法重载
		File[] listFiles = f.listFiles(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				// dir 表示上层文件夹
				// name 表示子文件名称
				File ff = new File(dir, name);
				if (name.toLowerCase().endsWith(suffix.toLowerCase()) & ff.isFile()) {
					return true;
				}
				return false;
			}
		});
	}
}

过滤器方式性能更好一些

6递归

递归：方法定义中调用方法本身的现象。

递归注意事项：

要有出口，否则就是死递归
次数不能太多，否则就内存溢出
构造方法不能递归使用

示例：

public class digui {
	public static void main(String[] args) {
		int n = Recursion(100);
		System.out.println(n);
	}
	public static int Recursion(int num) {
		if (num == 1) {
			return 1;
		}
		return num + Recursion(num-1);
	}
}

斐波那契

public class RecursionDemo1 {
	public static void main(String[] args) {
		System.out.println(bronRabbit(10));
	}
	public static int bronRabbit(int month) {
		if(month ==1 || month ==2) {
			return 1;
		}else {
			return bronRabbit(month-1) + bronRabbit(month-2);
		}
	}
}

猴子吃桃：小猴子第一天摘下若干桃子，立刻吃了一半，又多吃一个，第二天早上又将剩下的桃子吃了一半，又多吃一个。依此类推，到第10天就剩下1个桃子，问，第一天一共有多少个桃子？
```
	public static int eatPeach(int day) {
		if (day == 10) {
			return 1;
		}else {
			return (eatPeach(day+1) + 1) *2;
		}
	}
```

递归文件查询

public class digui2 {
	public static void main(String[] args) {
		findAllFiles("d:/", ".jpg");
	}
	public static void findAllFiles(String path, String suffix) {
		File f = new File(path);
		if (f.isFile()) {
			if (f.getName().toLowerCase().endsWith(suffix.toLowerCase())) {
				System.out.println(f.getAbsolutePath());
			}
		}else {
			File[] listFiles = f.listFiles();
			if (listFiles != null && listFiles.length>0) {
				for (File file : listFiles) {
					findAllFiles(file.getAbsolutePath(),suffix);
				}
			}
		}
	}
}

递归删除

	public static void deletefindAllFiles(String path, String suffix) {
		File f = new File(path);
		if (f.isFile()) {
			f.delete();
		}else {
			File[] listFiles = f.listFiles();
			if (listFiles != null && listFiles.length>0) {
				for (File file : listFiles) {
					findAllFiles(file.getAbsolutePath(),suffix);
				}
			}
		}
		// 删除自己
		f.delete();
	}
}

IO流

1.文件本质

存储都是二进制数据，我们能够看到数据的具体形态，都是因为各自的软件我们都做了解码工作。

2.字节和字符区别

字节是存储容量基本单位，1字节=8个二进制位。
字符是指字母、数字、汉字和各种符号。
一个字符在计算机中若干个字节的二进制数表示

计算机中所有的数据能可以使用字节表示，但是只有纯文本文件才能使用字符表示。

3.读写和输入输出的关系

输入：读
输出：写

4.IO流分类

流向划分
```
输入流
输出流
```

处理单位

字节流：以字节为单位进行处理
字符流：以字符为单位进行处理

两两组合得到四个基类

字节输入流：InputStream
字节输出流:OutPutStream
字符输入流：Reader
字符输入流:Write

以InputStream结尾，都是属于字节输入流
以OutputStream结尾，都是属于字节输出流
以Readder 结尾的，都是属于字符输入流
以Writer结尾的，都是属于字符输出流

4.FileOutputStream/FileInputStream用法

4.1FileOutputStream字节输出流/FileInputStream字节输入流

FileOutputStream构造方法

FileOutputStream(File file)   文件对象
FileOutoutStream(String path)  路径
FileOutoutStream(String path, boolean append) append默认为false，表示是否追加写入

write方法

public void write(int b)写入一个字节
public void write(byte[] b)写入一个byte数组
public void write(byte[] b, int off, int len)写入一个数组，从off开始，len个长度

示例

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
	public static void main(String[] args) {
		FileOutputStream fos  = null;
		try {
			// 创建一个文件字节输出流的对象
			fos = new FileOutputStream("J:\java大数据\java基础\day16\a.txt");
			// 写入一个字节
			fos.write(23);
             // 写入一个byte数组
			fos.write("你好啊".getBytes());
			fos.write("你好啊".getBytes(),0,2);

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 关闭
			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
}

自动关流书写方式，写在try 括号后面

import java.io.FileOutputStream;

public class FileOutputStreamDemo2 {
	public static void main(String[] args) {
		try(
				FileOutputStream fos = new FileOutputStream("J:\java大数据\java基础\day16\a.txt",true);
				) {
				fos.write("hello".getBytes());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

FileInputStream构造方法

FileInputStream(File file)   文件对象
FileInputStream(String path)  路径

read方法

public int read()  一次只能读一个字节
public int read([]byte b)  一次能读一个数组个字节

示例:

import java.io.FileInputStream;

public class FileInputStreamDemo {
	public static void main(String[] args) {
		try (
				FileInputStream fis = new FileInputStream("J:\java大数据\java基础\day16\a.txt");
				){
			
			
			// 一次读一个字节
			int a = fis.read();
			int b = fis.read(); 
			int c = fis.read();
			byte[] bs = {(byte)a, (byte)b, (byte)c};
			String s = new String(bs);
			System.out.println(s);// 大
			System.out.println((char)a);
			// 一次读多个字节
			byte[] bbs = new byte[1024];
			// 读取真正读回来有效长度
			int len = fis.read(bbs);
			String ss = new String(bbs,0,len);
			System.out.println(ss);
			
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

如果没有内容可读，返回-1

循环读取文件：

import java.io.FileInputStream;

public class FileInputStreamDemo2 {
	public static void main(String[] args) {
		try(
				FileInputStream fis = new FileInputStream("J:\java大数据\java基础\day16\a.txt");
				) {
				byte[] bs =new byte[1024];
//				int len = fis.read(bs);
//				System.out.println(new String(bs,0,len));
				int len;
				// 
				while((len=fis.read(bs))!=-1) {
					System.out.println(new String(bs,0,len));
				}	
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.2文件拷贝工具类封装

/*
	 * @param srcPath:源文件路径
	 * @param destPath:目标文件路经
	 * */
	public static void copyFile(String srcPath, String destPath) {
		long start = System.currentTimeMillis();
		try(
					FileInputStream fis = new FileInputStream(srcPath);
					FileOutputStream fos = new FileOutputStream(destPath);
				) {
			byte[] bs = new byte[1024];
			int len;
			while((len=fis.read())!=-1) {
				fos.write(bs,0,len);
			}
			long end = System.currentTimeMillis();
			System.out.println("文件拷贝成功,耗时：" + (end - start) + "毫秒");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

4.3缓冲字节的用法

使用字节流每次从文件中进行读写时候，都需要和文件进行大量io交互，与磁盘交互的效率其实比较低的。所以为了降低与磁盘交互次数，可以使用缓冲字节流，缓冲字节流先将数据放到缓冲区，我们直接和缓冲区做交互，可以提高效率。

缓冲字节流输出流

BufferedOutputStream(OutputStream)
flush:缓冲输出流中特有的方法，将缓冲区中内容写到文件中
close:会先调用flush方法，再关流

缓冲字节输入流

BufferedInputStream(InputStream)
BufferedInputStream(InputStream, int size) size:缓冲区大小，默认8K

缓冲输出流示例

public class BufferedOutputStreamDemo {
	public static void main(String[] args) {
		// 使用BufferedOutputStream包装OutputStream
		try(
				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("J:\java大数据\java基础\day16\c.txt"));
				) {
			bos.write(97);
			bos.write("你好".getBytes());
			// 刷入文件中,当执行关闭文件时，也会自动将数据刷入文件
			bos.flush();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

缓冲流输入：

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class BufferedInputStreamDemo {
	public static void main(String[] args) {
		
		try(
				// 8192为缓冲区默认大小，也可以自定义大小
				BufferedInputStream bis = new BufferedInputStream(new FileInputStream("J:\java大数据\java基础\day16\c.txt"),8192);
				) {
			byte[] bs = new byte[1024];
			int len;
			while((len=bis.read(bs))!=-1) {
				System.out.println(new String(bs,0,len));
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.4 转换流

字符流可以认为字节流与编码表的结合。

OutputStreamWriter 字符输出流

public OutputStreamWriter(OutputStream out)
public OutputStreamWriter(OutputStream out, String charsetName)

方法：

public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf, int off, int len)
public void write(String str)
public void write(String str,int off,int len)

示例：

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class OutStreamWriteDemo {
	public static void main(String[] args) {
		
		try(
				OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("J:\java大数据\java基础\day16\d.txt", true),"gbk");
				) {
			osw.write(97);
			char[] chs = {'你', '好'};
			osw.write(chs,0,1);
			osw.write("你好啊");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

InputStreamReader 字符输入流

public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in, String charsetName)

方法：

public int read()
public int read(char[] cbuf)

示例

import java.io.FileInputStream;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
	public static void main(String[] args) {
		
		try(
				InputStreamReader isr = new InputStreamReader(new FileInputStream("J:\java大数据\java基础\day16\c.txt"),"gbk");
				) {
			char[] chs = new char[1024];
			int len;
			while((len=isr.read(chs))!=-1) {
				System.out.println(new String(chs,0,len));
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

转换流拷贝只能拷贝文本文件

public static void copyFileByInputStreamReaderAndOutputStreamWriter(String srcPath,String destPath) {
		long start = System.currentTimeMillis();
		try(
				InputStreamReader isr =new InputStreamReader(new FileInputStream(srcPath));
				OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destPath));
				) {
			char[] chs = new char[1024];
			int len;
			while((len=isr.read())!=-1) {
				osw.write(chs,0,len);
			}
			long end = System.currentTimeMillis();
			System.out.println("文件拷贝成功,耗时：" + (end - start));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

4.5 简化流

转换流的名字较长，而我们常见的操作都是按照本地默认编码实现的，所以为了简化我们书写，转换流提供对应子类。
```
FIleWriter
FileReader
```

写入

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
	public static void main(String[] args) {
		try(
			// 默认编码，无法指定编码，可以设置是否追加
			FileWriter fw = new FileWriter("d:/ccc.txt");
				) {
			fw.write("你好啊");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

读取

import java.io.FileReader;

public class FileReaderDemo {
	public static void main(String[] args) {
		try(
			FileReader fr = new FileReader("d:/ccc.txt");
				) {
			char[] chs = new char[1024];
			int len;
			while((len=fr.read(chs)) != -1) {
				System.out.println(new String(chs,0,len));
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.6缓冲字节流

	public static void copyFileByBufferedReaderAndBufferedWriter(String srcPath,String destPath) {
		long start = System.currentTimeMillis();
		try(
				BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(srcPath)));
				BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(destPath)));
				) {
			char[] chs = new char[1024];
			int len;
			while((len=br.read(chs))!=1) {
				bw.write(chs,0,len);
			}
			long end = System.currentTimeMillis();
			System.out.println("文件拷贝成功(缓冲字符流),耗时：" + (end - start));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

4.7 序列化和对象流

Java序列化是指把Java对象转换成为字节序列的过程，反序列化是指把字节序列回复为Java对象的过程。当两个Java进程进行通信时，发送方需要把这个Java对象转换成为字节序列，然后在网络上传送，另一方面，接收方需要从字节序列中回复Java对象。
序列化：把对象转成二进制
反序列化：把二进制转换成对象
持久化：把内存数据存储到硬盘上（一般指数据库）

实现序列化步骤

1.让类实现Serializable接口
2.使用ObjectOutPutStream 写数据，调用writeObject
3.使用ObjectInputStream 读数据，调用readObject

写入

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;



public class ObjectOutputStreamDemo {
	public static void main(String[] args) {
		try(
				ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("J:\java大数据\java基础\day16\mast.dll"));
				) {
			Person p = new Person("小明",15);
			oos.writeObject(p);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

读出

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInptStreamDemo {
	public static void main(String[] args) {
		try (
				ObjectInputStream ois = new ObjectInputStream(new FileInputStream("J:\java大数据\java基础\day16\mast.dll"));
				) {
			Object o = ois.readObject();
			System.out.println(o instanceof Person);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

注意：当对象修改Person类时，执行读入会报错：java.io.InvalidClassException错误，是由于模板改变造成。因为在执行写入操作时候会生成一个版本号：serialVersionUID,修改Person对象造成版本号不一致。解决方式：

1.重新执行写入，在读

2.生成序列化id:鼠标悬浮Person类，点击 Add default serial versionID或Add generated serial version ID

练习1：把ArrayList集合中字符串数据存储到文本文件（每条数据占一行），从文本文件中读取数据（每一行为一个字符串数据）到集合中，并遍历集合。

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class lianxi1 {
	public static void main(String[] args) {
		// 创建String   List
		List<String> list = new ArrayList<>();
		// 往集合中添加元素
		list.add("javase");
		list.add("javaee");
		list.add("linux");
		list.add("hadoop");
		list.add("scala");
		list.add("spark");
		// 创建缓冲字符输出流
		try(
				// 创建缓冲字符输出流
				BufferedWriter bw = new BufferedWriter(new FileWriter("J:\java大数据\java基础\day16\g.txt"));
				BufferedReader br = new BufferedReader(new FileReader("J:\java大数据\java基础\day16\g.txt"));
				) {
			// 遍历集合获取每个元素
			ListIterator<String> it = list.listIterator();
			while (it.hasNext()) {
				String s = it.next();
				// 把每条数据写到文件中，并换行
				bw.write(s);
				// 换行
				bw.newLine();
			}
			bw.close();// 先写后读，先关流
			
			List<String> newList = new ArrayList<>();
			// 读取每一条数据
			String line;
			while((line=br.readLine())!=null) {
				System.out.println(line);
				// 把读取数据存储到集合
				newList.add(line);
			}
			// 遍历集合打印
			for(int i=0;i<newList.size();i++) {
				System.out.println(newList.get(i));
			}

			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

4.8总结

FileInputStream/FileOutputStream	文件字节流
BufferedInputStream/BufferedOutputStream	缓冲字节流
InputStreamReader/OutputStreamWriter	转换流 把字节流转成字符流 可指定编码
FileReader/FileWriter	简化流	不能指定编码
BufferedReader/BufferedWriter	缓冲字符流	newLine/readLine
ObjectInputStream/ObjectOutputStream	对象流  序列化、反序列化	Serialiazable writeObject/readObject

5.Properties配置文件读取

目的是为了便于维护
创建properties文件

// config.properties
date.format=yyy-MM-dd HH:mm:ss

加载配置文件

import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo {
	public static void main(String[] args) {
		try {
			// 创建Properties对象
			Properties p = new Properties();
			// 加载配置文件
			// PropertiesDemo.class.getClassLoader() 为了得到ClassLoader对象。
			// ClassLoader中方法getResourceAsStream加载配置文件
			p.load(PropertiesDemo.class.getClassLoader().getResourceAsStream("config.properties"));
			// 获取信息：
			String value = p.getProperty("date.format");
			System.out.println(value);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

相关阅读:
shell编程－项目部署（优化篇）
数据库相关
 python基础面试
 scrapy爬取数据进行数据库存储和本地存储
 C# 对字符串操替换数字替换非数字去除首尾字符长沙
 还在为删除集合中的相同项而烦恼吗？
C#之Task&匿名方法
 如何在火狐里面实现如下功能
 valueOf和toString曾经欺骗过你吗？
JS 实现Json查询方法
原文地址：https://www.cnblogs.com/xujunkai/p/13872730.html