文章目录
File类
- 概念：代表物理盘符中的一个或文件夹
- 方法：
- createNewFile()//创建一个新文件
- mkdir()//创建一个新目录
- delete()//删除文件或空目录
- exists()//判断File对象所代表的的对象是否存在
- getAbsolutePath()//获取文件的绝对路劲
- getName()//取得名字
- getParent()//获取文件/目录所在的目录
- isDirectory()//是否是目录
- isFile()//是否是文件
- length()//获得文件的长度。
- listFiles()//列出目录中的所有内容.
- renameTo()//修改文件名为
文件
文件操作
-
1.创建文件
File file = new File("d:\\desktop\\aa.txt"); if (!file.exists()) { boolean newFile = file.createNewFile(); System.out.println("创建结果" + newFile); } else { System.out.println("文件已经存在."); } -
2.删除文件
//2.1直接删除 boolean b1 = file.delete(); System.out.println("删除结果" + b1); //2.2Jvm删除 Thread.sleep(5000); file.deleteOnExit(); -
3.获取文件信息
System.out.println("文件长度：" + file.length()); System.out.println("文件名称" + file.getName()); System.out.println("文件绝对路径：" + file.getAbsolutePath()); System.out.println("规范路径路径" + file.getCanonicalPath()); System.out.println("文件路径：" + file.getPath()); System.out.println("文件父目录:" + file.getParent()); System.out.println("文件最后一次修改时间：" + new Date(file.lastModified()).toLocaleString()); -
4.判断
System.out.println("是否存在" + file.exists()); System.out.println("是否只读:" + file.canWrite()); System.out.println("是否隐藏:" + file.isHidden()); System.out.println("是不是文件：" + file.isFile()); -
5.修改名称(具有剪切的功能)
file.renameTo(new File("d:\\desktop\\sb"));
目录（文件夹）
-
1.创建文件夹
File dir = new File("d:\\aaa\\b\\c"); if (!dir.exists()) { //dir.mkdir()//创建单级目录 boolean b = dir.mkdirs();//创建多级目录 System.out.println("创建结果：" + b); } else { System.out.println("创建失败"); } -
2.删除文件夹
//2.1直接删除：只删除最里层目录，必须是空的 boolean b2 = dir.delete(); // dir.deleteOnExit(); System.out.println("删除结果"+b2); -
3.获取信息
System.out.println("获取路劲" + dir.getPath()); System.out.println("获取绝对路劲" + dir.getAbsolutePath()); System.out.println("获取名称" + dir.getName()); System.out.println("规范名称" + dir.getCanonicalPath()); -
4.判断
System.out.println("是否存在" + dir.exists()); System.out.println("是否隐藏" + dir.isHidden()); System.out.println("是不是文件夹:" + dir.isDirectory()); -
5.重命名
// boolean b = dir.renameTo(new File("d:\\desktop\\aaa\\b\\d")); // System.out.println(b); -
6.获取目录的子目录和文件
File dir2 = new File("D:\\desktop"); String[] list = dir2.list(); for (String s : list) { System.out.println(s); } File[] files = dir.listFiles(); for (File file : files) { System.out.println(file.toString()); } System.out.println("==================="); //获取目录下的.pptx String[] list1 = dir2.list(new FilenameFilter() { @Override public boolean accept(File dir, String name) { if (name.endsWith(".pptx")) { return true; } return false; } }); for (String s : list1) { System.out.println(s); } File[] files1 = dir2.listFiles(new FileFilter() { @Override public boolean accept(File pathname) { if (pathname.toString().endsWith(".pptx")) { return true; } return false; } }); for (File file : files1) { System.out.println(file.getName()); } //获取根目录 File[] files2 = dir2.listRoots(); for (File file : files2) { System.out.println(file.toString()); }
1.练习，递归遍历文件夹
2.递归删除文件夹
public static void listDir(File dir, int level) {
File[] files = dir.listFiles();
if (files != null && files.length > 0) {
for (File file : files) {
if (file.isDirectory()) {
System.out.println(getSeprator(level)+file.getName());
listDir(file, ++level);
} else {
System.out.println(getSeprator(level) + file.getName());
}
}
}
}
public static String getSeprator(int level) {
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < level; i++) {
stringBuilder.append(" ");
}
return stringBuilder.toString();
}
public static void deleteList(File dir){
File[] files = dir.listFiles();
if(files!=null&&files.length>0){
for (File file : files) {
if(file.isDirectory()){
deleteList(file);
}else {
System.out.println(file.getName()+"删除结果"+file.delete());
}
}
System.out.println(dir.getName()+"删除结果"+dir.delete());
}
}
FileFilter接口
- public interface FileFilter
- boolean accept(File pathname)
- 当调用File类中的listFiles()方法时，支持传入fileFilter接口接口实现类，当获取文件进行过滤，只有f符合条件的文件的才可出现在listFiles()的返回值中。
什么是流
- 概念：内存与存储设备之间的传输数据的通道。
流的分类
-
按方向
- 输入流（读取）：将<存储设备>中的内容读到<内存>中 .（外设–》内存）
- 输出流（写入）：将<内存>中的内容写入的<存储设备>中。
-
按单位：
- 字节流：以字节为单位，可以读写所有数据。
- 字符流：以字符为单位，只能读写文本数据
-
按功能：
- 节点流：具有实际传输数据的读写功能。
- 过滤流：在节点流的基础之上增强功能。
-
输入输出是以内存为基点。
字节流
-
字节流的父类（抽象类）
- InputStream:字节输入流
- public int read()
- public int read(byte[]b){}
- public int read(byte[]b,int off,int len);
- OutputStream:字节输出流
- public void write(int n){}
- public void write(byte[]b){}
- public void write(byte[]b,int off,int length)
- InputStream:字节输入流
-
write方法
文件字节流
- FileOutputStream:
- public void write(byte[]b)//一次写多个字节，将b数组中所有的字节，写入输入流。
- FileInputStream:
- public int read(byte[]b)//从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1；
- 字节读取
- 1.1单个字节读取
// //1.创建文件字节输入流
InputStream inputStream = new FileInputStream(new File("d:\\desktop\\demo.txt"));
//2.读文件
//2.1单个字节读取
int data = 0;
while ((data = inputStream.read()) != -1) {
System.out.println((char) data);
}System.out.println(data);
// 3.关闭流
inputStream.close();
1.2读取多个字节
// //1.创建文件字节输入流
InputStream inputStream = new FileInputStream(new File("d:\\desktop\\demo.txt"));
//2.2读取多个字节
byte[] buf = new byte[1024];
int len = 0;
while ((len = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, len));
}
inputStream.close();
2.1写入
//1.创建流
File file = new File("d:\\desktop\\test.txt");
OutputStream outputStream = new FileOutputStream(file, true);//append
//2.写入
String word = "Hello wordl\r\n";
for (int i = 0; i < word.length(); i++) {
outputStream.write(word.getBytes());//直接写入文件
}
//3.关闭
outputStream.close();
字节缓冲流
- 缓冲流：BufferedOutputStream/BufferedInputStream
- 提高IO效率，减少访问磁盘的次数；
- 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close;
- 1.1缓冲流输入单个读取
//1.创建缓冲字节输入流
FileInputStream fileInputStream = new FileInputStream("d:\\desktop\\test02.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
//2.读取
//2.1单个字节读取
int data = 0;
while ((data = bufferedInputStream.read()) != -1) {
System.out.println((char) data);
}
//3.关闭，关闭缓冲流，自动关闭节点流
bufferedInputStream.close();
- 1.2多个字节读取
//1.创建缓冲字节输入流
FileInputStream fileInputStream = new FileInputStream("d:\\desktop\\test02.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
//2.2读取多个字节
byte[] buffer = new byte[1024];
int len = 0;
while ((len = bufferedInputStream.read()) != -1) {
System.out.println(new String(buffer, 0, len));
}
bufferedInputStream.close()
- 2.缓冲输出流
//1.创建缓冲输出流
FileOutputStream fileOutputStream = new FileOutputStream("d:\\desktop\\test02.txt");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//2.写入
String word = "nice meet to you\r\n";
for (int i = 0; i < 5; i++) {
bufferedOutputStream.write(word.getBytes());
bufferedOutputStream.flush();
}
//3.关闭:默认刷新，关闭底层节点流。
bufferedOutputStream.close();
- 实例，实现赋值文件
//1.创建缓冲字节流输入，输出流
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("d:\\desktop\\girl.jpg"));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("d:desktop\\girl_copy.jpg"));
//2.边读边写
byte[] buffer = new byte[1024];
int len = 0;
while ((len = bufferedInputStream.read(buffer)) != -1) {
bufferedOutputStream.write(buffer, 0, len);
bufferedOutputStream.flush();
}
bufferedInputStream.close();
bufferedOutputStream.close();
- 实现2
FileOutputStream fileOutputStream = new FileOutputStream("d:\\desktop\\girl_copy01.jpg");
FileInputStream fileInputStream = new FileInputStream("d:\\desktop\\girl.jpg");
byte[] buffer = new byte[1024];
int len = 0;
while ((len = fileInputStream.read(buffer)) != -1) {
fileOutputStream.write(buffer, 0, len);
}
fileInputStream.close();
fileOutputStream.close();
对象流
- 对象流：ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能：
- readObject()从流中读取一个对象
- writeObject(Object obj)向流中写入一个对象
- 使用流传输对象的过程称为序列化，反序列化。
对象序列化
- 对象序列化的细节
- 必须实现Serializable接口
- 必须保证其所有属性均可序列化
- transient修饰为临时 属性，不参加序列化
- 读取到文件尾部的标志：java.io.EOFException.
- serialVersionUID
注意：
1.序列化的类必须实现Serializable（自动序列化几口）或Externalizable(收到序列化接口).
2.序列化的类要添加一个私有的long类型j静态常量：serverVersionUID,保证序列化的类反序列化的类是同一个类。
实现:1)使用transient修饰的属性，不可以序列化
2)静态属性不能序列化使用transient修饰的属性实例化吗？
可以，同时实现Externalizable，手动序列化
- 序列化和反序列化
//序列化 Person 必须继承Serializable接口
public static void testSerializable() throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("d:\\desktop\\demo.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
Person person1 = new com.demodong.practice.demo04.Person("demodong1", 12);
Person person2 = new com.demodong.practice.demo04.Person("demodong2", 12);
Person person3 = new com.demodong.practice.demo04.Person("demodong3", 12);
Person person4 = new com.demodong.practice.demo04.Person("demodong4", 12);
ArrayList<com.demodong.practice.demo04.Person> persons = new ArrayList<>();
persons.add(person1);
persons.add(person2);
persons.add(person3);
persons.add(person4);
objectOutputStream.writeObject(persons);
objectOutputStream.close();
}
public static void testSerializable2() throws IOException, ClassNotFoundException {
FileInputStream fileInputStream = new FileInputStream("d:\\desktop\\demo.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
ArrayList<Person> persons = (ArrayList<com.demodong.practice.demo04.Person>) objectInputStream.readObject();
for (Person person : persons) {
System.out.println(person.toString());
}
}
//继承Externalizable,需要重写方法
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
int object = (int) in.readObject();
}
字符编码
- ISO-8859-1 收录除ASCII外，还包括修，希腊语。。
- UTF-8 针对Unicode的可变长度字符编码
- GB2312 简体中文
- GBK 简体中文，扩充
- BIG5 台湾，繁体中文
- 当编码方式和解码方式不一致时，会出现乱码
字符流
- 字符流的父类（抽象）：
- Reader:字符输入流
- public int read(){}
- public int read(char[]c)
- public int read(char[],int off,int len){}
- Write:字符输出流
- public void write(int n){}
- public void write(String str){}
- public void write(char[]c){}
- Reader:字符输入流
文件字符流
-
FileWriter:
- public void write(String str)//一次写多个字符，将b数组中所有的字符，写入输入流。
-
FileReader:
- public int read(char[]c)//从流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1；
-
1.1字符输出流
//1.创建字符文件输出流
FileWriter fileWriter = new FileWriter("d:\\desktop\\demo.txt", true);
//2.写入
for (int i = 0; i < 10; i++) {
fileWriter.write("jiava真香");
fileWriter.flush();
}
fileWriter.close();
- 2.1字符输入流
FileReader fr=new FileReader("d:\\desktop\\demo.txt");
int len=0;
char []buffers=new char[1024];
while((len=fr.read(buffers))!=-1){
System.out.println(new String(buffers,0,len));
}
fr.close();
字符缓冲流
- 缓冲流：BufferedWriter/BufferedReader
- 支持输入换行符。
- 可一次写一行，读一行。
public static void write() throws IOException {
//1.创建字符缓冲流
FileWriter fileWriter = new FileWriter("d:\\desktop\\demo.txt", true);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
for (int i = 0; i < 10; i++) {
bufferedWriter.write("我爱phtyon");
bufferedWriter.newLine();
bufferedWriter.flush();
}
bufferedWriter.close();
}
public static void read() throws IOException {
//1.创建字符缓冲流输出流
FileReader fileReader = new FileReader("d:\\desktop\\demo.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
String data = null;
while ((data = bufferedReader.readLine()) != null){
System.out.println(data);
}
bufferedReader.close();
}
- PrintWriter:
- 封装了print()/println()方法，支持写入后换行。
- 支持数据原样打印
//1.创建打印流
PrintStream printStream = new PrintStream("d:desktop\\demo.txt");
//2.打印
printStream.println(97);
//3.关闭
printStream.close();
转换流
- 桥转换流：InputStreamReader/OutputStreamWriter
- 可将字节流转化为字符流
- 可设置字符的编码方式。
- InputStreamReadr:字节流通向字符流的桥梁
- OutputStreamWriter:字符流通向字节流的桥梁
- 步骤
- 创建节点流
- [创建过滤流 设置字符编码集]
- 封装过滤流
- 读写数据
- 关闭流
InputStreamReader.contructor()
InputStreamReader.read()
OutputStreamWriter.constructor()
OutputStreamWriter.write()
OutputStreamWriter.getEncoding()
public static void write() throws IOException {
//创建转换流
FileOutputStream fileOutputStream = new FileOutputStream("d:desktop\\demo.txt", true);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "UTF8");
//写入
for (int i = 0; i < 10; i++) {
outputStreamWriter.write("你好呀\r\n");
outputStreamWriter.flush();
}
//关闭
outputStreamWriter.close();
}
public static void read() throws IOException {
//1.创建缓冲农六
FileInputStream fileInputStream = new FileInputStream("d:\\desktop\\demo.txt");
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "gbk");
//2.读取
char[] buf = new char[1024];
int len = 0;
while ((len = inputStreamReader.read(buf)) != -1) {
System.out.println(String.valueOf(buf));
}
inputStreamReader.close();
}
重定向标砖输出流
System.setOut()
System.setOut(new PrintStream("d:\\desktop\\demo.txt"));
System.out.println("Nihao");
int data = System.in.read();
System.out.println((char) data);
InputStreamReader inputStreamReader = new InputStreamReader(System.in);
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
String data=bufferedReader.readLine();
System.out.println(data);
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
String data = bufferedReader.readLine();
System.out.println(data);
RandomAccessFile
- RandomAccessFile即可以读取文件内容，也可以像文件中写入内容。
- 但是和其他输入输出流不同的是，程序可以直接跳到文件的任意位置来读写数据。
- 读写模式
- r:只读
- rw:读写
- 作用
- 快速定位数据，支持并发读写
- 方便的获取二进制文件。
Constructor
read()
- 同时支持readInt…
write()
readUTF()
seek()
public static void write() throws IOException {
//1.创建随机读写文件类
RandomAccessFile raf = new RandomAccessFile("d:\\desktop\\demo.txt", "rw");
//2.写
raf.writeUTF("你好");
raf.writeInt(102);
raf.writeBoolean(true);
raf.writeDouble(120);
raf.writeUTF("buhao");
raf.writeInt(102);
raf.writeBoolean(true);
raf.writeDouble(120);
raf.close();
}
public static void read() throws IOException {
//1.创建随机读写文件类
RandomAccessFile raf = new RandomAccessFile("d:\\desktop\\demo.txt", "r");
//2.读写
//跳过
//seek()从开头位置0，设置文件指针的偏移量
// raf.seek(24);
// raf.skipBytes();
System.out.println(raf.readUTF());
System.out.println(raf.readInt());
System.out.println(raf.readBoolean());
System.out.println(raf.readDouble());
raf.close();
}
Properties集合
- Properties:属性集合。
- 特点：
- 存储属性名和属性值。
- 属性名和属性值都是字符串类型。
- 没有泛型。
- 和流有关。
setProperty()
getProperty
list()
store()
load()
//Properties和流相关的方法
//创建集合
Properties prop = new Properties();
//添加元素
prop.setProperty("username", "password");
prop.setProperty("zhangsan", "password");
prop.setProperty("lisi", "password");
//3.1list 遍历
// prop.list(System.out);
PrintWriter writer = new PrintWriter("d:\\desktop\\demo.properties");
prop.list(writer);
writer.close();
//3.2store
// FileWriter f =new FileWriter("d:\\desktop\\demo.txt");
// FileOutputStream f =new FileOutputStream("d:\\desktop\\demo.txt");
// prop.store(f, "用户信息");
//
//4.读取 load加载文件
Properties prop2 = new Properties();
// FileReader fileReader = new FileReader("d:\\desktop\\demo.txt");
FileInputStream fileReader = new FileInputStream("d:\\desktop\\demo.txt");
prop2.load(fileReader);
fileReader.close();
prop2.list(System.out);
932
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
