FileUtil文件工具简单应用

最新推荐文章于 2022-04-15 11:10:51 发布

原创最新推荐文章于 2022-04-15 11:10:51 发布 · 3.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java文件操作工具 #反射

IT修真-法宝-开发工具专栏收录该内容

12 篇文章

订阅专栏

这篇博客介绍了FileUtil文件操作工具类的应用，包括文件的增删改查、移动文件和内容读取。文章重点是利用反射获取包下所有类，并提供了相关测试验证和反射知识的补充。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

该file文件操作工具类实现功能包括：文件的增删改查，移动文件，文件内容的读取，较大的特点是通过反射获取包下所有类。后面做了简单测试验证以及一些反射相关知识补充。

一）简单文件操作：增删改查

import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 *文件操作工具类
 *
 * @author xiu
 * @version 2017年7月31日 下午8:17:13 
 */
public class FileUtil {
	
	private FileUtil() {
	}

	/**
	 * 列出指定文件夹的内容 
	 * 
	 * @param dir 指定文件夹的路径
	 * @return 指定文件夹的内容
	 */
	public static String[] ls(String dir) {
		File file = new File(dir);
		if (file.exists()) {
			return file.list();
		}
		return new String[0];
	}
	
    /**
     * 在指定的位置创建指定的文件
     *
     * @param filePath 完整的文件路径
     * @param mkdir 是否创建相关的文件夹
     * @throws Exception
     */
    public static void mkFile(String filePath, boolean mkdir) throws Exception {
        File file = new File(filePath);
        file.getParentFile().mkdirs();
        file.createNewFile();
        file = null;
    }
    
    /**
     * 在指定的位置创建文件夹
     *
     * @param dirPath 文件夹路径
     * @return 若创建成功，则返回True；反之，则返回False
     */
    public static boolean mkDir(String dirPath) {
        return new File(dirPath).mkdirs();
    }
    
	/**
	 * 写入文件(完全自定义文件格式和写入内容)
	 * 
	 * @param filename 文件名(可包含路径)
	 * @param data 要写入的数据
	 * @param flag 是否追加(true追加，false不追加)
	 * @return boolean
	 */
	public static boolean write(String filename, String data, boolean flag) {
		int i = filename.lastIndexOf('/');
		File file = new File(filename.substring(0, i));
		if (!file.exists()) {
			file.mkdirs();
		}
		try {
			FileWriter fw = new FileWriter(filename, flag);
			fw.write(data);
			fw.flush();
			fw.close();
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 删除某个文件或目录 2012-3-13
	 * 
	 * @param filename
	 *            文件名或目录
	 * @return 0：删除成功，-1：指定文件夹不存在，-2：指定文件不存在
	 */
	public static int delete(String filename) {
		File file = new File(filename);
		if (file.isDirectory()) {
			String[] dir = ls(filename);
			for (int i = 0; i < dir.length; i++) {
				new File(filename + "/" + dir[i]).delete();
				if (file.isDirectory()) {
					delete(filename + "/" + dir[i]);
				}
			}
			if (file.delete()) {
				return 0;
			} else {
				return -1;
			}
		} else if (file.isFile()) {
			if (file.delete()) {
				return 0;
			} else {
				return -2;
			}
		} else {
			return -1;
		}
	}
	
    /**
     * 移动指定的文件（夹）到目标文件（夹）
     * @param source 源文件（夹）
     * @param target 目标文件（夹）
     * @param isFolder 若为文件夹，则为True；反之为False
     * @return
     * @throws Exception
     */
    public static boolean move(String source, String target, boolean isFolder)
            throws Exception {
        copy(source, target, isFolder);
        if (isFolder) {
            return delDir(source, true);
        } else {
            return delFile(source);
        }
    }

    /**
     * 删除指定的文件
     *
     * @param filePath 文件路径
     *
     * @return 若删除成功，则返回True；反之，则返回False
     *
     */
    public static boolean delFile(String filePath) {
        return new File(filePath).delete();
    }
 
    /**
     * 删除指定的文件夹
     *
     * @param dirPath 文件夹路径
     * @param delFile 文件夹中是否包含文件
     * @return 若删除成功，则返回True；反之，则返回False
     *
     */
    public static boolean delDir(String dirPath, boolean delFile) {
        if (delFile) {
            File file = new File(dirPath);
            if (file.isFile()) {
                return file.delete();
            } else if (file.isDirectory()) {
                if (file.listFiles().length == 0) {
                    return file.delete();
                } else {
                    int zfiles = file.listFiles().length;
                    File[] delfile = file.listFiles();
                    for (int i = 0; i < zfiles; i++) {
                        if (delfile[i].isDirectory()) {
                            delDir(delfile[i].getAbsolutePath(), true);
                        }
                        delfile[i].delete();
                    }
                    return file.delete();
                }
            } else {
                return false;
            }
        } else {
            return new File(dirPath).delete();
        }
    }
    /**
     * 复制文件/文件夹 若要进行文件夹复制，请勿将目标文件夹置于源文件夹中
     * @param source 源文件（夹）
     * @param target 目标文件（夹）
     * @param isFolder 若进行文件夹复制，则为True；反之为False
     * @throws Exception
     */
    public static void copy(String source, String target, boolean isFolder)
            throws Exception {
        if (isFolder) {
            (new File(target)).mkdirs();
            File a = new File(source);
            String[] file = a.list();
            File temp = null;
            for (int i = 0; i < file.length; i++) {
                if (source.endsWith(File.separator)) {
                    temp = new File(source + file[i]);
                } else {
                    temp = new File(source + File.separator + file[i]);
                }
                if (temp.isFile()) {
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(target + "/" + (temp.getName()).toString());
                    byte[] b = new byte[1024];
                    int len;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if (temp.isDirectory()) {
                    copy(source + "/" + file[i], target + "/" + file[i], true);
                }
            }
        } else {
            int byteread = 0;
            File oldfile = new File(source);
            if (oldfile.exists()) {
                InputStream inStream = new FileInputStream(source);
                File file = new File(target);
                file.getParentFile().mkdirs();
                file.createNewFile();
                FileOutputStream fs = new FileOutputStream(file);
                byte[] buffer = new byte[1024];
                while ((byteread = inStream.read(buffer)) != -1) {
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
                fs.close();
            }
        }
    }

读取文件内容

	/**
	 * 读取文件类容
	 * 
	 * @param filename 文件名(可包含路径)
	 * @return 文件类容
	 */
	public static String read(String filename) {
		try {
			String text = null;
			StringBuilder sb = new StringBuilder();
			BufferedReader input = new BufferedReader(new FileReader(filename));
			while ((text = input.readLine()) != null) {
				sb.append(text);
				sb.append("\n");
			}
			input.close();
			return sb.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return "";
	}

二）复杂文件操作：

	/**
	 * 获取包下面所有类
	 * @param pack  文件夹路径
	 * @return
	 */
	public static Set<Class<?>> getClasses(String pack) {

		// 第一个class类的集合
		Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
		// 是否循环迭代
		boolean recursive = true;
		// 获取包的名字 并进行替换
		String packageName = pack;
		String packageDirName = packageName.replace('.', '/');
		// 定义一个枚举的集合 并进行循环来处理这个目录下的things
		Enumeration<URL> dirs;
		try {
			dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
			// 循环迭代下去
			while (dirs.hasMoreElements()) {
				// 获取下一个元素
				URL url = dirs.nextElement();
				// 得到协议的名称
				String protocol = url.getProtocol();
				// 如果是以文件的形式保存在服务器上
				if ("file".equals(protocol)) {
					//System.err.println("file类型的扫描");
					// 获取包的物理路径
					String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
					// 以文件的方式扫描整个包下的文件 并添加到集合中
					findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
				} else if ("jar".equals(protocol)) {
					// 如果是jar包文件
					// 定义一个JarFile
					//System.err.println("jar类型的扫描");
					JarFile jar;
					try {
						// 获取jar
						jar = ((JarURLConnection) url.openConnection()).getJarFile();
						// 从此jar包 得到一个枚举类
						Enumeration<JarEntry> entries = jar.entries();
						// 同样的进行循环迭代
						while (entries.hasMoreElements()) {
							// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
							JarEntry entry = entries.nextElement();
							String name = entry.getName();
							// 如果是以/开头的
							if (name.charAt(0) == '/') {
								// 获取后面的字符串
								name = name.substring(1);
							}
							// 如果前半部分和定义的包名相同
							if (name.startsWith(packageDirName)) {
								int idx = name.lastIndexOf('/');
								// 如果以"/"结尾 是一个包
								if (idx != -1) {
									// 获取包名 把"/"替换成"."
									packageName = name.substring(0, idx).replace('/', '.');
								}
								// 如果可以迭代下去 并且是一个包
								if ((idx != -1) || recursive) {
									// 如果是一个.class文件 而且不是目录
									if (name.endsWith(".class") && !entry.isDirectory()) {
										// 去掉后面的".class" 获取真正的类名
									String className = name.substring(packageName.length() + 1, name.length() - 6);
										try {
											// 添加到classes
											classes.add(Class.forName(packageName + '.' + className));
										} catch (ClassNotFoundException e) {
											// log
											// .error("添加用户自定义视图类错误
											// 找不到此类的.class文件");
											e.printStackTrace();
										}
									}
								}
							}
						}
					} catch (IOException e) {
						// log.error("在扫描用户定义视图时从jar包获取文件出错");
						e.printStackTrace();
					}
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}

		return classes;
	}

	public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
			Set<Class<?>> classes) {
		// 获取此包的目录 建立一个File
		File dir = new File(packagePath);
		// 如果不存在或者 也不是目录就直接返回
		if (!dir.exists() || !dir.isDirectory()) {
			// log.warn("用户定义包名 " + packageName + " 下没有任何文件");
			return;
		}
		// 如果存在 就获取包下的所有文件 包括目录
		File[] dirfiles = dir.listFiles(new FileFilter() {
			// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
			public boolean accept(File file) {
				return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
			}
		});
		// 循环所有文件
		for (File file : dirfiles) {
			// 如果是目录 则继续扫描
			if (file.isDirectory()) {
				findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
						classes);
			} else {
				// 如果是java类文件 去掉后面的.class 只留下类名
				String className = file.getName().substring(0, file.getName().length() - 6);
				try {
					// 添加到集合中去
					// classes.add(Class.forName(packageName + '.' +
					// className));
					// 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
					classes.add(
							Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
				} catch (ClassNotFoundException e) {
					// log.error("添加用户自定义视图类错误 找不到此类的.class文件");
					e.printStackTrace();
				}
			}
		}
	}

三）实例应用

检测某个包下文件类名相同的Java类

import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import com.xiu.util.FileUtil;

/**
 *
 * @author xiu
 * @version 2017年7月31日 上午11:06:30 
 */
public class CheckFileUtil {
	
	/**
	 * java文件路径
	 */
	public static final  String protobufPath = new String("com.xiu.test"); 
	
	public static void main(String[] args) {
		checkSameFile();
        }
	/**
	 * 检查相同名字的协议体
	 */
	public static void checkSameFile(){
		//Java文件拿到所有协议体
		 Set<Class<?>> clazzSet = FileUtil.getClasses(protobufPath);
		 Set<String> sameFileNameSet = new HashSet<>();
		 int num = 0;
		 //遍历每一个java文件类，与其他的类比较
		 for (Class<?> clazz : clazzSet) {
			 String longName = new String(clazz.getName()); //类全名、含包名
			 String simpleName = new String(clazz.getSimpleName());//简单文件名，不含包名
        	 if (clazz.getName().contains("$1") || sameFileNameSet.contains(simpleName)) {
                 continue;
             }
        	String sameName = null;
        	 for (Class<?> clazz1 : clazzSet) {//与其他文件相比较
            	 if (clazz1.getName().contains("$1") ) {
                     continue;
                 }
            	 String longName2 = new String(clazz1.getName()); 
            	 if (longName.equals(longName2) || longName == longName2) {
					continue;
				}
            	 if (clazz1.getSimpleName().equals(simpleName) || simpleName == clazz1.getSimpleName()) {
            		 sameName = new String(clazz1.getName()); 
            		 break;
				}
        	 }
        	if (sameName != null && sameName.length() > 0) {
        		num ++;
        		sameFileNameSet.add(simpleName);
        		System.out.println("the same javaFile num is : " + num);
        		System.out.println("one is :" + longName);
        		System.out.println("another javaFileName is:" + sameName);
        		System.out.println("===================================================");
			}
        	
        }
	}

	
}

四）java获取当前路径的几种方法

1、利用System.getProperty()函数获取当前路径：
System.out.println(System.getProperty("user.dir"));//user.dir指定了当前的路径

2、使用File提供的函数获取当前路径：
File directory = new File("");//设定为当前文件夹
try{
    System.out.println(directory.getCanonicalPath());//获取标准的路径
    System.out.println(directory.getAbsolutePath());//获取绝对路径
}catch(Exceptin e){}

File.getCanonicalPath()和File.getAbsolutePath()大约只是对于new File(".")和new File("..")两种路径有所区别。

# 对于getCanonicalPath()函数，“."就表示当前的文件夹，而”..“则表示当前文件夹的上一级文件夹
# 对于getAbsolutePath()函数，则不管”.”、“..”，返回当前的路径加上你在new File()时设定的路径
# 至于getPath()函数，得到的只是你在new File()时设定的路径

比如当前的路径为 C:/test ：
File directory = new File("abc");
directory.getCanonicalPath(); //得到的是C:/test/abc
directory.getAbsolutePath();    //得到的是C:/test/abc
direcotry.getPath();                    //得到的是abc

File directory = new File(".");
directory.getCanonicalPath(); //得到的是C:/test
directory.getAbsolutePath();    //得到的是C:/test/.
direcotry.getPath();                    //得到的是.

File directory = new File("..");
directory.getCanonicalPath(); //得到的是C:/
directory.getAbsolutePath();    //得到的是C:/test/..
direcotry.getPath();                    //得到的是..

另外：System.getProperty()中的字符串参数如下：
System.getProperty()部分参数
# java.version                                Java Runtime Environment version
# java.vendor.url                           Java vendor URL
# java.home                                Java installation directory
# line.separator                       Line separator ("/n" on UNIX)
# user.name                        User’s account name
# user.home                              User’s home directory
# user.dir                               User’s current working directory

补：javaWeb中获取路径:

1.jsp中取得路径：
以工程名为TEST为例：
(1)得到包含工程名的当前页面全路径：request.getRequestURI()
结果：/TEST/test.jsp
(2)得到工程名：request.getContextPath()
结果：/TEST
(3)得到当前页面所在目录下全名称：request.getServletPath()
结果：如果页面在jsp目录下 /TEST/jsp/test.jsp
(4)得到页面所在服务器的全路径：application.getRealPath("页面.jsp")
结果：D:/resin/webapps/TEST/test.jsp
(5)得到页面所在服务器的绝对路径：absPath=new java.io.File(application.getRealPath(request.getRequestURI())).getParent();
结果：D:/resin/webapps/TEST

2.在类中取得路径：
(1)类的绝对路径：Class.class.getClass().getResource("/").getPath()
结果：/D:/TEST/WebRoot/WEB-INF/classes/pack/
(2)得到工程的路径：System.getProperty("user.dir")
结果：D:/TEST

3.在Servlet中取得路径：
(1)得到工程目录：request.getSession().getServletContext().getRealPath("") 参数可具体到包名。
结果：E:/Tomcat/webapps/TEST
(2)得到IE地址栏地址：request.getRequestURL()
结果：http://localhost:8080/TEST/test
(3)得到相对地址：request.getRequestURI()
结果：/TEST/test