1、File类简介
在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象。File 类定义了一些与平台无关的方法来操作文件，File类主要用来获取或处理与磁盘文件相关的信息，像文件名、 文件路径、访问权限和修改日期等，还可以浏览子目录层次结构。 File 类表示处理文件和文件系统的相关信息。也就是说，File 类不具有从文件读取信息和向文件写入信息的功能，它仅描述文件本身的属性。
2、构造方法
构造器
File(String pathname) 通过将给定路径名字符串来创建一个新 File 实例
File(String parent,String child) 根据指定的父路径和文件路径创建一个新File对象实例
File(File parent,String child) 根据指定的父路径对象和文件路径创建一个新的File对象实例
3、File类创建和删除功能
boolean createNewFile() 指定路径不存在该文件时创建文件，返回true 否则false
boolean mkdir() 当指定的单击文件夹不存在时创建文件夹并返回true 否则false
boolean mkdirs() 当指定的多级文件夹在某一级文件夹不存在时，创建多级文件夹并返回true 否则false
boolean delete() 删除文件或者删除单级文件夹
4、File类的判断功能
boolean exists() 判断指定路径的文件或文件夹是否为空
boolean isAbsolute() 判断当前路径是否是绝对路径
boolean isDirectory() 判断当前的目录是否存在
boolean isFile() 判断当前的目录是否是一个文件
boolean isHidden() 判断当前路径是否是一隐藏文件
5、File类的获取功能和修改名字功能
File getAbsoluteFile() 获取文件的绝对路径，返回File对象
String getAbsolutePath() 获取文件的绝对路径，返回路径的字符串
String getParent() 获取当前路径的父级路径，以字符串形式返回该父级路径
String getName() 获取文件或文件夹的名称
String getPath() 获取File对象中封装的路径
long lastModified() 以毫秒值返回最后修改时间
long length() 返回文件的字节数
boolean renameTo(File dest) 将当前File对象所指向的路径修改为指定File所指向的路径
6、文件夹列表操作
返回值 方法 描述
String list() 得到这个文件夹下的所有文件，返回路径数组
String[] list(FilenameFilter filter) 通过过滤器过滤文件，过滤通过文件名过滤，返回路径数组
File[] listFiles() 得到这个文件夹下的所有文件，返回文件数组
File[] listFiles(FileFilter filter) 通过过滤器过滤文件，过滤通过文件过滤，返回文件数组
File[] listFiles(FilenameFilter filter) 通过过滤器过滤文件，过滤通过文件名过滤，返回文件数组
对读写操作的拷贝运用
package io;
import org.junit.Test;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class IoTest {
@Test
//在进行写的时候可以写未读到的，也可以写读到储存在数组中的
public void readTest() throws IOException {
File file = new File("D:\\IDEA激活\\a.txt");
InputStream inputStream = new FileInputStream(file);
int len;
byte[] bytes = new byte[3];
StringBuilder stringBuilder = new StringBuilder();
while ((len = inputStream.read(bytes)) != -1) {
//每次读出多少字节就转换为字符串，在进行追加
String s = new String(bytes, 0, len);
stringBuilder.append(s);
}
System.out.println(stringBuilder);
}
@Test
public void writeTest() throws IOException {
File file = new File("D:\\IDEA激活\\a.txt");
OutputStream outputStream = new FileOutputStream(file, true);
byte[] bytes = {97, 98, 99, 100};
outputStream.write("Hello World".getBytes(StandardCharsets.UTF_8));
}
@Test
public void copyFileTest() throws IOException {
//建立输入流
InputStream inputStream = new FileInputStream("D:\\IDEA激活\\b\\a.txt");
//建立输出流
OutputStream outputStream = new FileOutputStream("D:\\IDEA激活\\a\\a.txt");
//建立缓冲区
byte[] buf = new byte[1024 * 1024];
int len;
//开始读写操作
while ((len = inputStream.read(buf)) != -1) {
outputStream.write(buf, 0, len);//偏移量
}
}
@Test
public void copyFileTest2() throws IOException {
InputStream inputStream = null;
OutputStream outputStream = null;
try {
//建立输入流
inputStream = new FileInputStream("D:\\IDEA激活\\b\\a.txt");
//建立输出流
outputStream = new FileOutputStream("D:\\IDEA激活\\a\\a.txt");
//建立缓冲区
byte[] buf = new byte[1024 * 1024];
int len;
//开始读写操作
while ((len = inputStream.read(buf)) != -1) {
outputStream.write(buf, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
assert inputStream != null;
assert outputStream != null;
inputStream.close();
outputStream.close();
}
}
@Test
public void copyFileTest3() {
//自动关闭流
try ( //建立输入流
InputStream inputStream = new FileInputStream("D:\\IDEA激活\\b\\a.txt");
//建立输出流
OutputStream outputStream = new FileOutputStream("D:\\IDEA激活\\a\\a.txt",true)) {
//建立缓冲区
byte[] buf = new byte[1024 * 1024];
int len;
//开始读写操作
while ((len = inputStream.read(buf)) != -1) {
outputStream.write(buf, 0, len);
System.out.println();
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
public void copyFileTest4() throws IOException {
//字符流
//建立输入流
Reader reader = new FileReader("D:\\IDEA激活\\b\\a.txt");
//建立输出流
Writer writer = new FileWriter("D:\\IDEA激活\\a\\a.txt",true);
int b;
//开始读写操作
while ((b = reader.read()) != -1) {
writer.write(b);
}
reader.close();
writer.close();
}
@Test
public void copyFileTest5() throws IOException {
//字符流
//建立输入流
Reader reader = new FileReader("D:\\IDEA激活\\b\\a.txt");
//建立输出流
Writer writer = new FileWriter("D:\\IDEA激活\\a\\a.txt");
char[] buf = new char[1024];
int len;
//开始读写操作
while ((len = reader.read(buf)) != -1) {
writer.write(buf, 0, len);
}
reader.close();
writer.close();
}
@Test
public void BufferReadFileTest() throws IOException {
//创建输入流
Reader reader = new FileReader("D:\\IDEA激活\\a\\a.txt");
//创建处理流
BufferedReader bufferedReader = new BufferedReader(reader);
//bufferedReader 读取到的是字符串
String content;
while ((content = bufferedReader.readLine()) != null) {
System.out.println(content);
}
bufferedReader.close();
reader.close();
}
//应为要在控台输入 所以要用主函数
//BufferedWriter测试
public static void main(String[] args) throws IOException {
//创建输入流
Writer writer = new FileWriter("D:\\IDEA激活\\b\\a.txt",true);
//创建处理流
BufferedWriter bufferedWriter = new BufferedWriter(writer);
System.out.println("请输入文件内容到D:\\IDEA激活\\b\\a.txt");
//buffer读取到的是字符串
while (true) {
Scanner scanner = new Scanner(System.in);
String Content = scanner.next();
bufferedWriter.write(Content);
bufferedWriter.newLine();
bufferedWriter.flush();
}
}
}
Serializable序列化运用
package io;
import org.junit.Test;
import java.io.*;
//对象达到徐序列化时，里面如果有对象也必须达到序列化
public class SerializableTest {
//序列化
@Test
public void SerializableTest1() throws IOException {
OutputStream outputStream = new FileOutputStream("D:\\IDEA激活\\a\\a.txt");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(new User(12, "张三"));
outputStream.close();
objectOutputStream.close();
}
//反序列化
@Test
public void SerializableTest2() throws IOException, ClassNotFoundException {
InputStream inputStream = new FileInputStream("D:\\IDEA激活\\a\\a.txt");
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
User user = (User) objectInputStream.readObject();
System.out.println(user);
inputStream.close();
objectInputStream.close();
}
//根据序列化进行深浅拷贝
@Test
public void ShallowCloneTest() throws CloneNotSupportedException {
User user = new User(14, "张万森");
user.setDog(new Dog(11, "沸羊羊"));
User user1 = (User) user.clone();
user1.setAge(12);
user1.setName("燕子");
//在这里我只改动了user1但是user的dog也被改动 。原本应该是new Dog(11,"沸羊羊")，但是在我改动了user1的dog的时候，我的user的dog也被改动
//所以应该运用序列化再深拷贝
user1.getDog().setName("双面龟");
System.out.println("user = " + user);
System.out.println("user1 = " + user1);
}
@Test
public void DeepCloneTest() throws IOException, ClassNotFoundException {
User user=new User(12,"张三");
user.setDog(new Dog(12,"李四"));
User user1 = DeepCopyUtil.deepcopy(user);
System.out.println("user= " + user);
System.out.println("user1 = " + user1);
}
}
进行读取对象序列化时
防止输入输出不一致！！！
深拷贝对象方法
package io;
import java.io.*;
public class DeepCopyUtil {
public static <T> T deepcopy(T t) throws IOException, ClassNotFoundException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(t);
//获取字节数组
byte[] bytes = byteArrayOutputStream.toByteArray();
//开始读取进来
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object object = objectInputStream.readObject();
//关流避免内耗
objectInputStream.close();
byteArrayInputStream.close();
objectOutputStream.close();
byteArrayOutputStream.close();
return (T)object;
}
}
小案例：对文本的增，删，改，查商品的方法
package operation;
import java.io.*;
import java.util.*;
public class method {
static Scanner scanner = new Scanner(System.in);
public static void insert(String path) {
boolean flag = true;
int id = scanner.nextInt();
//防止id重复
while (flag) {
System.out.println("请输入商品编号");
List<Goods> goodsList = FindAll(path);
Optional<Goods> first = goodsList.stream().filter(p -> p.getId() == id).findFirst();
flag = first.isPresent();
scanner.nextInt();
if (flag) {
System.out.println("商品重复");
}
}
System.out.println("请输入商品名字");
String name = scanner.next();
System.out.println("请输入商品价格");
int price = scanner.nextInt();
method.writeGoods(path,Arrays.asList(new Goods(id,name,price)),true);
//追加
}
public static void delete(String path) {
boolean tager = true;
int id = scanner.nextInt();
//防止id重复
while (tager) {
System.out.println("请输入商品编号");
List<Goods> goodsList = FindAll(path);
Optional<Goods> first = goodsList.stream().filter(p -> p.getId() == id).findFirst();
tager = first.isPresent();
scanner.nextInt();
if (tager) {
System.out.println("商品不存在");
}
}
List<Goods> goodsList = FindAll(path);
Iterator<Goods> iterator = goodsList.iterator();
while (iterator.hasNext()) {
Goods next = iterator.next();
if (next.getId() == id) {
iterator.remove();
}
}
//刷入磁盘
method.writeGoods(path,goodsList,false);
}
public static void update(String path) {
boolean tager = true;
int id = scanner.nextInt();
//防止id重复
while (tager) {
System.out.println("请输入商品编号");
List<Goods> goodsList = FindAll(path);
Optional<Goods> first = goodsList.stream().filter(p -> p.getId() == id).findFirst();
tager = first.isPresent();
scanner.nextInt();
if (tager) {
System.out.println("商品不存在");
}
}
System.out.println("请输入商品名字");
String name = scanner.next();
System.out.println("请输入商品价格");
int price = scanner.nextInt();
List<Goods> goodsList = FindAll(path);
Iterator<Goods> iterator = goodsList.iterator();
while (iterator.hasNext()) {
Goods goods = iterator.next();
if (goods.getId() == id) {
goods.setName(name);
goods.setPrice(price);
}
}
method.writeGoods(path,goodsList,false);
}
//查找所有商品
public static List<Goods> FindAll(String path) {
//可自动关闭的流输入法
List<Goods> goodsList = new ArrayList<>();
try (Reader reader = new FileReader(path);
BufferedReader bufferedReader = new BufferedReader(reader)) {
String goodsStr;
while ((goodsStr = bufferedReader.readLine()) != null) ;
String[] goodsitem = goodsStr.split(" ");
Goods goods = new Goods(Integer.parseInt(goodsitem[0]), goodsitem[1], Integer.parseInt(goodsitem[2]));
goodsList.add(goods);
System.out.println(goodsList + "\r\n");
} catch (IOException e) {
e.printStackTrace();
}
return goodsList;
}
public static void check(String path) {
List<Goods> goodsList = method.FindAll(path);
for (Goods goods : goodsList) {
System.out.println(goods.getId() + goods.getName() + goods.getPrice());
}
}
public static void selectOne(String path) {
System.out.println("请输入商品编号");
int id = scanner.nextInt();
List<Goods> goodsList = method.FindAll(path);
Optional<Goods> first = goodsList.stream().filter(p -> p.getId() == id).findFirst();
if (first.isPresent()) {
Goods goods = first.get();
System.out.println(goods.getId() + goods.getName() + goods.getPrice());
} else {
System.out.println("你找的商品不存在");
}
}
public static void writeGoods(String path,List<Goods> goodsList,boolean appened) {
//刷入磁盘
try (Writer writer = new FileWriter(path,appened);
BufferedWriter bufferedWriter = new BufferedWriter(writer)) {
for (Goods goods : goodsList) {
bufferedWriter.write(goods.getId() + goods.getName() + goods.getPrice());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
