1、文件操作--file1.1 访问文件或文件夹（目录）的属性
getName();获取当前文件名字的方法 length();获取当前文件的长度 canWrite();判断文件是否可写 canRead();判断文件是否可读 isHidden();判断文件是否隐藏 isFile();判断当前路径是否是文件 isDriectory();判断当前路径是否是文件夹 getParent();获取当前路径的父级结构 getAbsolutePath();获取当前文件的完整路径
访问文件的路径 要看文件的名字 名字中带后缀 则加后缀 不带则不加
访问文件夹的路径 没有后缀，直接写文件路径即可
package day01;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) throws IOException {
//1.访问文件
//pathName --- 文件路径
//文件路径分类：
// 绝对路径 : 指的是通过路径可以绝对的能访问到当前电脑的位置(开发基本不用 太局限.)
// 相对路径 : ./ 指的是相对应用程序(项目) 的路径 ----(开发必用)
//访问文件一般是要加后缀的.
File file = new File("./demo.txt");//访问文件的方式
//1.获取当前文件路径的名字
String fileName = file.getName();
System.out.println(fileName);
//2.获取当前文件的长度 (字节)
long length = file.length();
System.out.println(length);
//3.获取当前文件是否可写
System.out.println("是否可写:" + file.canWrite());
System.out.println("是否可读:" + file.canRead());
//4.获取当前文件是否隐藏
System.out.println("是否隐藏:"+ file.isHidden());
//5.可以当前file这个对象路径 是否是文件
System.out.println("是否是文件:"+file.isFile());
//6.可以获取当前文件存不存在的状态.
System.out.println("文件是否存在"+file.exists());
//7.获取当前文件所在的父级路径
System.out.println("当前文件的父级路径:"+ file.getParent());
//8.获取当前文件的完整路径
System.out.println("当前文件的完整路径"+file.getAbsolutePath());
}
}
1.2 创建和删除文件或者文件夹（目录）
1.2.1 创建文件
package day01;
import java.io.File;
import java.io.IOException;
public class CreateFileDemo {
public static void main(String[] args) throws IOException {
//在当前项目路径下创建一个文件
File file = new File("./demo2.txt");//创建一个文件路径对象
if(file.exists()){//判断当前文件路径的物理文件是否存在.
System.out.println("文件已存在,不能进行创建");
}else {
//光标选中 错误提示 alt + Enter + Enter
file.createNewFile();
System.out.println("创建文件成功!!");
}
}
}
1.2.2 删除文件/文件夹
package day01;
import java.io.File;
import java.lang.reflect.Field;
public class DeleteDirDemo {
public static void main(String[] args) {
//删除文件夹
File dir = new File("./test/a/b/c/d/e");//一个文件夹路径的对象
if(dir.exists()){//判断文件夹是否存在
dir.delete();//只能删除空的文件夹
//System.out.println("已删除");
}else {
//System.out.println("文件不存在");
}
//删除文件
File file = new File("./demo2.txt");//一个文件路径的对象
if(file.exists()){ //判断文件是否存在
file.delete();//删除文件
System.out.println("删除成功");
}else {
System.out.println("文件不存在!");
}
}
}
1.3 访问一个文件夹（目录）下的所有子项
package day01;
import java.io.File;
public class ListFilesDemo {
public static void main(String[] args) {
//获取当前项目路径下的所有子项
File dir = new File(".");//一个文件夹路径对象
if(dir.isDirectory()){//判断当前dir路径是否是文件夹
File[] files = dir.listFiles();
System.out.println(files.length);
for (int i = 0; i < files.length; i++) {//遍历File数组 获取数组中每个文件
System.out.println(files[i].getName());//打印每个文件的名字
}
}
}
}
1.4 递归删除文件夹：
递归（recursion）：是程序中常见的解决问题的方法（使用频率尽可能限制，因为效率低下）
递归使用时 ，容易产生死循环，使用递归的时候，一定要加if语句（做一个出口）
递归的思想：自己调自己（本方法内部调用本方法），也可以间接的调用自己
循环是重复执行某段代码，递归的重复是个过程
main{
recursion();
}
public void recursion(){
...
recursion();
...
}
package day01;
import java.io.File;
public class RecursionDemo {
public static void main(String[] args) {
deleteDir(new File("./test"));
System.out.println("执行删除操作。");
}
public static void deleteDir(File file){
if(file.isDirectory()){//判断当前文件路径是否是文件夹
//若是 获取下该文件夹有没有子项
File[] files = file.listFiles();//获取文件夹下所有子项
for (int i = 0; i < files.length; i++) {
deleteDir(files[i]);//递归：调用本方法传递子项路径
}
}
file.delete();//执行删除
}
}
获取文件夹（目录）下的所有子项，也可以有条件的进行获取
1.5 文件过滤器package day01;
import java.io.File;
import java.io.FileFilter;
public class ListFilesDemo2 {
public static void main(String[] args) {
//获取当前项目路径下的子项
File file = new File(".");
FileFilter filter = new FileFilter() {//创建文件过滤器的匿名内部类
@Override
public boolean accept(File filePath) { //重写实现 过滤的条件
//contains 判断内容是否包含 o 这个字母
return filePath.getName().contains("o");//过滤条件为true 则将文件存储(过滤)起来
}
}; //方法参数 通过ctrl + P 查看
File[] files = file.listFiles(filter);//传入文件过滤器对象
System.out.println(files.length);
for (int i = 0; i < files.length; i++) {
System.out.println(files[i].getName());
}
}
}
1.6 Lambda表达式
JDK1.8以后，Java支持了lambda表达式
lambda表达式更好的关注逻辑如何去写，而不是语法，这样的写法是编译器认可的，但是.class文件会被还原
lambda表达式：使用匿名内部类实现接口，且接口只有一个抽象方法才能使用
package day01;
import java.io.File;
import java.io.FileFilter;
public class LambdaDemo {
public static void main(String[] args) {
//获取当前项目路径下的子项
File file = new File(".");
// FileFilter filter = new FileFilter() {
// @Override
// public boolean accept(File filePath) {
// return filePath.getName().contains("o");
// }
// };
//lambda 表达式的语法: 可以忽略 new FileFilter(接口名) 和 内部重写的方法名
//1.可以忽略 new FileFilter(接口名) 和 内部重写的方法名
FileFilter filter1 = (File filePath) ->{
return filePath.getName().contains("o");
};
//2.当 内部方法的形式参数 只有一个的话 则参数类型可以省略 小括号可以省略
FileFilter filter2 = filePath ->{
return filePath.getName().contains("o");
};
//3.若内部重写的方法 方法体只有一行代码的话 {} 可以不写 return 也不要写
FileFilter filter3 = filePath -> filePath.getName().contains("o");
// File[] files1 = file.listFiles( filePath -> filePath.getName().contains("o"));
File[] files = file.listFiles(filter3);
for (int i = 0; i < files.length; i++) {
System.out.println(files[i].getName());
}
}
}
2、IO流2.1 io简介：
In/Out：相对于程序而言的输出（读取）输出（写出）的过程。
即：通过Java程序到磁盘读取数据的过程，我们成为In的过程，也就是读取（输入）
价格Java程序充的数据写入磁盘的过程，我们成为Out的顾鹏程，也就是写出（输出）
在Java中，根据处理的数据单位不通，分为字节流和字符流
字节流：一个字节（byte）一个字节的去读取，或者写出
字符流：一个字符一个字符的去读取或者写出
JDK核心类库中提供了IO相关的类，这些类都在
流的概念：
程序中俄数据读取和写入，可以想象成水流在管道中流动
--流只能单方向流动
--输入流用来读取in
--输入流用来写出out
--数据只能从头到尾顺序的读取一次或写出一次
节点流：可以从或向一个特定的地方（节点）读写数据
处理流：是对一个已存在的连接和封装，通过所封装的流的功能实现数据读写
处理流的特点：处理留的构造方法总是要带一个其他的流对象做参考，一个流对象经过其他流的多次包装，成为流的连接
通常节点流也被称之为低级流，处理流也被称之为高级流或者过滤流
节点流
OutputStream抽象类：此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节，并将这些字节发送到某个接收器
FileOutputStream字节输出流：直接插在文件上，直接写出文件数据
创建对象
FileOutputString(String name)
创建一个向具有特定名称的文件中写入数据的输出文件流
FileOutputString(File name)
创建一个向指定File对象 表示的文件中写入数据的文件输出流
FileOutputStream（File file，Boolean append）-追加
创建一个向指定File对象表示的文件中写入数据的文件输出流
注意：以上构造方法中，如果参数指向的文件以及父目录都不存在，将会抛出FileNotFoundException异常！
如果参数指向的文件不存在，但文件所在的目录存在，将不会抛出异常，程序会自动创建该文件
字节流和字符流：
字节流：针对二进制文件（文本，图片，音频，视频....）
InputStream(包含input都是输入流)
-- FileInputStream
-- BufferedInputStream
-- ObjectInputStream
OutputStream（包含output的都是输出流）
-- FileOutputStream
-- BufferedOutputStream
-- ObjectOutputStream
字符流：针对文本文件，读写容易发生乱码现象，在读写时最好指定编码集为utf-8
reader（reader结尾的都是字符输入流）
-- FileReader
-- BufferedReader
-- InputStreamReader
Writer(Writer结尾的都是字符输出流)
-- FileWriter
-- BufferedWriter
-- OutputStreamWriter
-- PrintWriter/PrintStream
IO流表格：
2.2 代码案例 2.2.1 FileOutputStream//FileOutputStream代码案例
package Part02IO;
import java.io.*;
public class FOSDemo {
public static void main(String[] args) throws IOException {
// alt + enter + enter
//第一种：
FileOutputStream fos = new FileOutputStream("./fos.dat");
// //第二种：
// File file = new File("./fos.dat");
// FileOutputStream fos1 = new FileOutputStream(file);
//给 fos.dat 写入 00000001
fos.write(1);//写入int的数据 --1
//因为在上面已经为fos.dat写入 00000001 所以继续往后写入的话 会在后面追加
// 00000001 00000010
fos.write(2);
fos.close();//释放 (关闭流体)
}
}
InputStream 抽象类
此抽象没事表示字节输入流的的所有类的超类/抽象类
FileInputSteam 子类
直接插在文件上直接读取文件数据
创建对象
FileInputStream（File file）
通过打开一个实际文件的连接来创建一个FileInputStream，该文件通过文件系统的File对象file指定
FileInputStream(String pathname)
通过打开一个实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径名name指定
2.2.2 FileInputStream//FileInputStream代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.IOException;
public class FISDemo {
public static void main(String[] args) throws IOException {
//创建文件输入流 并指定 要处理的文件路径
FileInputStream fis = new FileInputStream("./fos.dat");
// d :00000000 00000000 00000000 00000001
int d = fis.read();
System.out.println(d);
// d:00000000 00000000 00000000 00000010
d = fis.read();
System.out.println(d);
// d:11111111 11111111 11111111 11111111
d = fis.read(); //文件末尾 -1
System.out.println(d);
fis.close();//需要释放
}
}
2.2.3 复制文件代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException {
//1.输入流
FileInputStream fis = new FileInputStream("./paimeng.jpg");//获取源图片
//2.输出流
FileOutputStream fos = new FileOutputStream("./paimeng_Copy.jpg");//目标图片位置
//如果读到的数据 为 -1 读到文件末尾
//不明确循环次数, 已知循环条件
int d; //alt + enter + enter
while ((d = fis.read()) != -1) { //如果读到的内容不为 -1的话
//获取当前读到的字节内容
fos.write(d);//写入到 目标文件中
}
System.out.println("拷贝完毕！");
fis.close(); //释放
fos.close();//释放
}
}
2.2.4 块读写优化代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
//1.输入流
FileInputStream fis = new FileInputStream("./1.pptx");//获取源图片
//2.输出流
FileOutputStream fos = new FileOutputStream("./1_copy.pptx");//目标图片位置
int d;
byte[] data = new byte[1024*10]; //10kb
long start = System.currentTimeMillis();//获取当前系统时间 毫秒单位
while ((d = fis.read(data)) != -1) { //块读
fos.write(data);//块写入
}
long end = System.currentTimeMillis();
System.out.println("拷贝完毕！拷贝时长:"+ (end - start)+"ms");
fis.close();//释放
fos.close();//释放
}
}
2.2.5 写入字符串
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class WriteStringDemo {
public static void main(String[] args) throws IOException {
//向一个文件名为demo1.txt写入文本数据
//crtl+alt+v 快速生成变量名
FileOutputStream fos = new FileOutputStream("demo1.txt");
String line = "beep,beep,i'm sheep~beep,beep,i'm sheep~";
byte[] data = line.getBytes(StandardCharsets.UTF_8);
fos.write(data);
fos.write("哔,哔,安慕希~哔,哔,安慕希~".getBytes(
StandardCharsets.UTF_8));
System.out.println("写出完毕!!!");
fos.close();
}
}
2.2.6 简易笔记本
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class TestNotes {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.println("请开始输入内容,单独输入exit退出~~");
//绑定要写出的文件是note.txt
FileOutputStream fos = new FileOutputStream("note.txt");
while (true){//一直循环接收用户输入的内容
//接收用户每次在控制台输入的字符串
String line = scanner.nextLine();
//如果输入的内容line是exit,退出程序(退出循环)
//不建议这种写法,因为line作为对象,可能会是null,就会引发空指针
//if (line.equals("exit")){}
//equalsIgnoreCase() 忽略大小写比较字符串
if ("exit".equals(line)){
break;//跳出当前循环
}
//将输入的内容写出到note.txt文件中
fos.write(line.getBytes(StandardCharsets.UTF_8));
}
// String line;
// while (!"exit".equals(line =scanner.nextLine())){
// fos.write(line.getBytes(StandardCharsets.UTF_8));
// }
fos.close();
}
}
2.2.7 文件追加模式案例
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
public class TestNotes2 {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("fos.txt", true);
String line = "你叉叉,穷哈哈~哈利波特骑着扫帚飞~~~sorry,sorry";
fos.write(line.getBytes(StandardCharsets.UTF_8));
System.out.println("写出完毕");
fos.close();
}
}
2.3 处理流
2.3.1 缓冲流
BufferedOutPutStream 缓冲输出流
BufferedInputStream 缓冲输入流
复制文件代码案例
package Part02IO;
import java.io.*;
public class CopyDemo3 {
public static void main(String[] args) throws Exception {
//创建一个文件字节输入流(低级流)
FileInputStream fis = new FileInputStream("1.pptx");
//创建一个缓冲字节输入流(高级流) 加快读取效率
BufferedInputStream bis = new BufferedInputStream(fis);
//创建一个文件字节输出流(低级流)
FileOutputStream fos = new FileOutputStream("1_copy2.pptx");
//创建一个缓冲字节输出流(高级流) 加快写出效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d;
long start = System.currentTimeMillis();
//此处需要使用高级流对象bis获取内容
while ((d = bis.read())!=-1){
//此处需要使用高级流对象bos写入内容
bos.write(d);
}
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start)+"ms");
//释放流资源 关闭流的顺序随意,而且只需要关闭高级流即可,会自动关闭连接的流
bis.close();
bos.close();
}
}
2.3.2 fush代码案例
package Part02IO;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class BOSFlushDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bos.txt");
//缓冲流内部维护了一个8K的字节数组,写出的数据都会先存入到这个数组中,
//只有数组存满时,才会写出
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("听我说谢谢你~因为有你,温暖了四季~~~".getBytes(StandardCharsets.UTF_8));
System.out.println("写出完毕!");
//flush 冲水 方法的作用是让缓冲输出流将其中的缓冲区中已经缓存的数据立即写出
bos.flush();
//bos.close();
}
}
2.4 对象流
package Part02IO;
import java.io.Serializable;
import java.util.Arrays;
public class Person implements Serializable {
static final long serialVersionUID = 1L;
private String name;//姓名
private int age;//年龄
private String gender;//性别
private transient String[] othreInfo;//其他信息
private int salary;//工资
//生成构造方法
public Person(String name, int age, String gender, String[] othreInfo) {
this.name = name;
this.age = age;
this.gender = gender;
this.othreInfo = othreInfo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String[] getOthreInfo() {
return othreInfo;
}
public void setOthreInfo(String[] othreInfo) {
this.othreInfo = othreInfo;
}
//生成toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
", othreInfo=" + Arrays.toString(othreInfo) +
", salary=" + salary +
'}';
}
}
2.4.1 OOSDemo案例
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class OOSDemo {
public static void main(String[] args) throws IOException {
String name = "song";
int age = 18;
String gender = "男";
String[] otherInfo = {"是一个帅哥","来自于11","爱好不明","广大妇女之友"};
Person p = new Person(name, age, gender, otherInfo);
System.out.println(p);//p.toString()
FileOutputStream fos = new FileOutputStream("person.obj");
//创建一个对象输出流,也是序列化流,是一个高级流
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
System.out.println("写出完毕!!!");
oos.close();
}
}
2.4.2 OISDemo案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream("person.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
}
2.5 转换字符流
2.5.1 OutputStreamWriter
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
public class OSWDemo {
public static void main(String[] args) throws IOException {
//向文件osw.txt中写入文本数据
//文件字节输出流(低级流)
FileOutputStream fos = new FileOutputStream("osw.txt");
// String line = "我欲成仙,法力无边!";
// byte[] data = line.getBytes(StandardCharsets.UTF_8);
// fos.write(data);
//字节字符转换流(高级流)
//在创建转换流时,通常需要指定第二个参数,明确使用的字符集
OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
osw.write("哈哈哈哈哈哈哈哈!");
osw.write("啦啦啦啦啦啦啦啦!");
System.out.println("写出完毕!");
osw.close();
}
}
2.5.2 InputStreamReader
package Part02IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
public class ISRDemo {
public static void main(String[] args) throws IOException {
//将osw.txt中的所有内容读取出来,并输出到控制台
//文件字节输入流(低级流)
FileInputStream fis = new FileInputStream("osw.txt");
//字符转换流(高级流)
//InputStreamReader
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
//读取一个字符,返回的int值是一个char
//但是若返回的是-1,表示读取到了末尾
// int d = isr.read();
// System.out.println((char)d);
int d;
while ((d=isr.read())!=-1){
//println 自带换行 print不带换行
System.out.print((char)d);
}
isr.close();
}
}
2.5.3 缓冲字符流
package Part02IO;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
public class PWDemo {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
PrintWriter pw = new PrintWriter("./pw.txt","UTF-8");
pw.println("哈哈哈哈哈哈哈哈!");
pw.println("啦啦啦啦啦啦啦啦!");
System.out.println("写出完毕");
pw.close();
}
}
2.5.4 在流链接中使用Printwriter
package Part02IO;
import java.io.*;
import java.util.Scanner;
public class PWDemo2 {
public static void main(String[] args) throws FileNotFoundException {
//文件字节输出流(低级流),向文件中写入字节数据
FileOutputStream fos = new FileOutputStream("pw2.txt",true);
//转换输出流(高级流,且是一个字符流),1.衔接字符与字节流 2.将写出的字符转换成字节
OutputStreamWriter osw = new OutputStreamWriter(fos);
//缓冲字符输出流(高级流),快读写加快效率
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
//完成简易的记事本,控制台输入的每行字符串都按行写入文件,输入exit时,退出
Scanner scanner = new Scanner(System.in);
while (true){
String line = scanner.nextLine();
//当输入的内容是exit时,不论大小写,就跳出循环
if ("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
}
pw.close();
}
}
