zoukankan      html  css  js  c++  java
  • Java常用工具类---IP工具类、File文件工具类

    package com.jarvis.base.util;

    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.LineNumberReader;

    /**
    *
    *
    * @Title: IpMacUtil.java
    * @Package com.jarvis.base.util
    * @Description:Ip工具类。
    * @version V1.0
    */
    public class IpMacUtil {

    /**
    * 隐藏IP的最后一段
    *
    * @param ip
    * 需要进行处理的IP
    * @return 隐藏后的IP
    */
    public static String hideIp(String ip) {
    if (StringHelper.isEmpty(ip)) {
    return "";
    }

    int pos = ip.lastIndexOf(".");
    if (pos == -1) {
    return ip;
    }

    ip = ip.substring(0, pos + 1);
    ip = ip + "*";
    return ip;
    }

    /**
    * 获取IP地址.
    *
    * @param request
    * HTTP请求.
    * @param response
    * HTTP响应.
    * @param url
    * 需转发到的URL.
    */
    // public static String getIpAddr(HttpServletRequest request)
    // {
    // String ip = request.getHeader("x-forwarded-for");
    // if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
    // {
    // ip = request.getHeader("Proxy-Client-IP");
    // }
    // if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
    // {
    // ip = request.getHeader("WL-Proxy-Client-IP");
    // }
    // if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
    // {
    // ip = request.getRemoteAddr();
    // }
    // return ip;
    // }

    /**
    * 判断该字串是否为IP
    *
    * @param ipStr
    * IP字串
    * @return
    */
    public static boolean isIP(String ipStr) {
    String ip = "(25[0-5]|2[0-4]\d|1\d\d|\d\d|\d)";
    String ipDot = ip + "\.";
    return ipStr.matches(ipDot + ipDot + ipDot + ip);
    }

    /**
    * 获取客户端Mac
    *
    * @param ip
    * @return
    */
    public static String getMACAddress(String ip) {
    String str = "";
    String macAddress = "";
    try {
    Process p = Runtime.getRuntime().exec("nbtstat -A " + ip);
    InputStreamReader ir = new InputStreamReader(p.getInputStream());
    LineNumberReader input = new LineNumberReader(ir);
    for (int i = 1; i < 100; i++) {
    str = input.readLine();
    if (str != null) {
    if (str.indexOf("MAC Address") > 1) {
    macAddress = str.substring(str.indexOf("MAC Address") + 14, str.length());
    break;
    }
    }
    }
    } catch (IOException e) {
    return "";
    }
    return macAddress;
    }

    }

    package com.jarvis.base.util;

    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.List;
    import java.util.StringTokenizer;
    import java.util.zip.CRC32;
    import java.util.zip.CheckedInputStream;

    import org.apache.commons.io.FilenameUtils;
    import org.dom4j.Document;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;

    /**
    *
    *
    * @Title: FileHelper.java
    * @Package com.jarvis.base.util
    * @Description:文件工具类
    * @version V1.0
    */
    public class FileHelper {

    /**
    * 1kb
    */
    private final static int KB_1 = 1024;

    /**
    * 获得文件的CRC32校验和
    *
    * @param file
    * 要进行校验的文件
    * @return
    * @throws Exception
    */
    public static String getFileCRCCode(File file) throws Exception {
    FileInputStream is = new FileInputStream(file);
    CRC32 crc32 = new CRC32();
    CheckedInputStream cis = new CheckedInputStream(is, crc32);
    byte[] buffer = null;
    buffer = new byte[KB_1];
    while (cis.read(buffer) != -1) {
    }
    is.close();
    buffer = null;
    return Long.toHexString(crc32.getValue());
    }

    /**
    * 获得字串的CRC32校验和
    *
    * @param string
    * 要进行校验的字串
    * @return
    * @throws Exception
    */
    public static String getStringCRCCode(String string) throws Exception {
    ByteArrayInputStream inputStream = new ByteArrayInputStream(string.getBytes());
    CRC32 crc32 = new CRC32();
    CheckedInputStream checkedinputstream = new CheckedInputStream(inputStream, crc32);
    byte[] buffer = null;
    buffer = new byte[KB_1];
    while (checkedinputstream.read(buffer) != -1) {
    }
    inputStream.close();
    buffer = null;
    return Long.toHexString(crc32.getValue());
    }

    /**
    * 连接路径和文件名称,组成最后的包含路径的文件名
    *
    * @param basePath
    * 文件路径
    * @param fullFilenameToAdd
    * 文件名称
    * @return
    */
    public static String concat(String basePath, String fullFilenameToAdd) {
    return FilenameUtils.concat(basePath, fullFilenameToAdd);
    }

    /**
    * 获得不带文件扩展名的文件名称
    *
    * @param filename
    * 文件完整路径
    * @return 不带扩展名的文件名称
    */
    public static String getBaseName(String filename) {
    return FilenameUtils.getBaseName(filename);
    }

    /**
    * 获得带扩展名的文件名称
    *
    * @param filename
    * 文件完整路径
    * @return 文件名称
    */
    public static String getFileName(String filename) {
    return FilenameUtils.getName(filename);
    }

    /**
    * 获得文件的完整路径,包含最后的路径分隔条
    *
    * @param filename
    * 文件完整路径
    * @return 目录结构
    */
    public static String getFullPath(String filename) {
    return FilenameUtils.getFullPath(filename);
    }

    /**
    * 获得文件的完整路径,不包含最后的路径分隔条
    *
    * @param filename
    * 文件完整路径
    * @return
    */
    public static String getFullPathNoEndSeparator(String filename) {
    return FilenameUtils.getFullPathNoEndSeparator(filename);
    }

    /**
    * 判断文件是否有某扩展名
    *
    * @param filename
    * 文件完整路径
    * @param extension
    * 扩展名名称
    * @return 若是,返回true,否则返回false
    */
    public static boolean isExtension(String filename, String extension) {
    return FilenameUtils.isExtension(filename, extension);
    }

    /**
    * 判断文件的扩展名是否是扩展名数组中的一个
    *
    * @param filename
    * 文件完整路径
    * @param extensions
    * 扩展名名称
    * @return 若是,返回true,否则返回false
    */
    public static boolean isExtension(String filename, String[] extensions) {
    return FilenameUtils.isExtension(filename, extensions);
    }

    /**
    * 规范化路径,合并其中的多个分隔符为一个,并转化为本地系统路径格式
    *
    * @param filename
    * 文件完整路径
    * @return
    */
    public static String normalize(String filename) {
    return FilenameUtils.normalize(filename);
    }

    /**
    * 规范化路径,合并其中的多个分隔符为一个,并转化为本地系统路径格式,若是路径,则不带最后的路径分隔符
    *
    * @param filename
    * 文件完整路径
    * @return
    */
    public static String normalizeNoEndSeparator(String filename) {
    return FilenameUtils.normalizeNoEndSeparator(filename);
    }

    /**
    * 把文件路径中的分隔符转换为unix的格式,也就是"/"
    *
    * @param path
    * 文件完整路径
    * @return 转换后的路径
    */
    public static String separatorsToUnix(String path) {
    return FilenameUtils.separatorsToUnix(path);
    }

    /**
    * 把文件路径中的分隔符转换为window的格式,也就是""
    *
    * @param path
    * 文件完整路径
    * @return 转换后的路径
    */
    public static String separatorsToWindows(String path) {
    return FilenameUtils.separatorsToWindows(path);
    }

    /**
    * 把文件路径中的分隔符转换当前系统的分隔符
    *
    * @param path
    * 文件完整路径
    * @return 转换后的路径
    */
    public static String separatorsToSystem(String path) {
    return FilenameUtils.separatorsToSystem(path);
    }

    /**
    * 提取文件的扩展名
    *
    * @param filename
    * 文件名称
    * @return 文件扩展名,若没有扩展名,则返回空字符串
    */
    public static String getExtension(String filename) {
    return FilenameUtils.getExtension(filename);
    }

    /**
    * 移出文件的扩展名
    *
    * @param filename
    * 文件名称
    * @return 若文件存在扩展名,则移出扩展名,然后返回移出后的值
    */
    public static String removeExtension(String filename) {
    return FilenameUtils.removeExtension(filename);
    }

    /**
    * 清除一个目录的内容,但不删除此目录
    *
    * @param directory
    * 需要清除的目录
    * @return true:清除成功 false:清除失败
    */
    public static boolean cleanDirectory(File directory) {
    try {
    org.apache.commons.io.FileUtils.cleanDirectory(directory);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("清除目录出错");
    }
    return false;
    }

    /**
    * 拷贝一个目录的内容到另外一个目录中
    *
    * @param srcDir
    * 源目录
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyDirectory(File srcDir, File destDir) {
    return copyDirectory(srcDir, destDir, true);
    }

    /**
    * 拷贝一个目录的内容到另外一个目录中
    *
    * @param srcDir
    * 源目录
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyDirectory(String srcDir, String destDir) {
    return copyDirectory(new File(srcDir), new File(destDir));
    }

    /**
    * 拷贝一个目录的内容到另外一个目录中
    *
    * @param srcDir
    * 源目录
    * @param destDir
    * 目的目录
    * @param preserveFileDate
    * 是否保持文件日期
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyDirectory(File srcDir, File destDir, boolean preserveFileDate) {
    try {
    org.apache.commons.io.FileUtils.copyDirectory(srcDir, destDir, preserveFileDate);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("复制目录出错");
    }
    return false;
    }

    /**
    * 拷贝源目录的内容到目的目录中(注:是拷贝到目的目录的里面)
    *
    * @param srcDir
    * 源目录
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyDirectoryToDirectory(File srcDir, File destDir) {
    try {
    org.apache.commons.io.FileUtils.copyDirectoryToDirectory(srcDir, destDir);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("复制目录出错");
    }
    return false;
    }

    /**
    * 拷贝源目录的内容到目的目录中(注:是拷贝到目的目录的里面)
    *
    * @param srcDir
    * 源目录
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyDirectoryToDirectory(String srcDir, String destDir) {
    return copyDirectoryToDirectory(new File(srcDir), new File(destDir));
    }

    /**
    * 拷贝文件
    *
    * @param srcFile
    * 源文件
    * @param destFile
    * 目的文件
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyFile(File srcFile, File destFile) {
    return copyFile(srcFile, destFile, true);
    }

    /**
    * 拷贝文件
    *
    * @param srcFile
    * 源文件路径
    * @param destFile
    * 目的文件路径
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyFile(String srcFile, String destFile) {
    return copyFile(new File(srcFile), new File(destFile));
    }

    /**
    * 拷贝文件
    *
    * @param srcFile
    * 源文件
    * @param destFile
    * 目的文件
    * @param preserveFileDate
    * 是否保留文件日期
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyFile(File srcFile, File destFile, boolean preserveFileDate) {
    try {
    org.apache.commons.io.FileUtils.copyFile(srcFile, destFile, preserveFileDate);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("复制文件出错");
    }
    return false;
    }

    /**
    * 拷贝文件到某目录中
    *
    * @param srcFile
    * 源文件
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyFileToDirectory(File srcFile, File destDir) {
    try {
    org.apache.commons.io.FileUtils.copyFileToDirectory(srcFile, destDir);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("复制文件出错");
    }
    return false;
    }

    /**
    * 拷贝文件到某目录中
    *
    * @param srcFile
    * 源文件
    * @param destDir
    * 目的目录
    * @return true:拷贝成功 false:拷贝失败
    */
    public static boolean copyFileToDirectory(String srcFile, String destDir) {
    return copyFileToDirectory(new File(srcFile), new File(destDir));
    }

    /**
    * 删除一个目录和该目录下的所有内容
    *
    * @param directory
    * 需要删除的目录
    * @return true:删除成功 false:删除失败
    */
    public static boolean deleteDirectory(String directory) {
    try {
    org.apache.commons.io.FileUtils.deleteDirectory(new File(directory));
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("删除目录出错");
    }
    return false;
    }

    /**
    * 删除文件
    *
    * @param file
    * 需要删除的文件路径
    * @return true:删除成功 false:删除失败
    */
    public static boolean deleteFile(String file) {
    try {
    org.apache.commons.io.FileUtils.forceDelete(new File(file));
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("删除文件出错");
    }
    return false;
    }

    /**
    * 递归创建目录
    *
    * @param directory
    * 目录
    * @return
    */
    public static boolean createDirectory(String directory) {
    try {
    org.apache.commons.io.FileUtils.forceMkdir(new File(directory));
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("创建目录出错");
    }
    return false;
    }

    /**
    * 读入文件到字节数组中
    *
    * @param file
    * 需要读取的文件路径
    * @return 读取的字节数组,若读入失败,则返回null
    */
    public static byte[] readFileToByteArray(String file) {
    try {
    byte[] bytes = org.apache.commons.io.FileUtils.readFileToByteArray(new File(file));
    return bytes;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("读取文件出错");
    }
    return null;
    }

    /**
    * 读入文件到字串中
    *
    * @param file
    * 需要读取的文件路径
    * @return 读取的文件内容,若读入失败,则返回空字串
    */
    public static String readFileToString(String file, String encoding) {
    try {
    if (StringHelper.isEmpty(encoding)) {
    encoding = "GBK";
    }
    String content = org.apache.commons.io.FileUtils.readFileToString(new File(file), encoding);
    return content;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("读取文件出错");
    }
    return "";
    }

    /**
    * 读入文件到字串中
    *
    * @param file
    * 需要读取的文件路径
    * @return 读取的文件内容,若读入失败,则返回空字串
    */
    public static String readFileToString(String file) {
    return readFileToString(file, "GBK");
    }

    /**
    * 读入文本文件到一个按行分开的List中
    *
    * @param file
    * 需要读取的文件路径
    * @return 按行内容分开的List
    */
    @SuppressWarnings("rawtypes")
    public static List readLines(String file) {
    return readLines(file, "GBK");
    }

    /**
    * 读入文本文件到一个按行分开的List中
    *
    * @param file
    * 需要读取的文件路径
    * @return 按行内容分开的List
    */
    @SuppressWarnings("rawtypes")
    public static List readLines(String file, String encoding) {

    try {
    if (StringHelper.isEmpty(encoding)) {
    encoding = "GBK";
    }
    List lineList = org.apache.commons.io.FileUtils.readLines(new File(file), encoding);
    return lineList;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("读取文件出错");
    }
    return null;

    }

    /**
    * 递归求一个目录的容量大小
    *
    * @param directory
    * 需要计算容量的目录路径
    * @return 容量的大小(字节数)
    */
    public static long sizeOfDirectory(String directory) {
    return org.apache.commons.io.FileUtils.sizeOfDirectory(new File(directory));
    }

    /**
    * 写字节数组到文件中,若文件不存在,则建立新文件
    *
    * @param file
    * 需要写的文件的路径
    * @param data
    * 需要写入的字节数据
    * @return true:写入成功 false:写入失败
    */
    public static boolean writeToFile(String file, byte[] data) {
    try {
    org.apache.commons.io.FileUtils.writeByteArrayToFile(new File(file), data);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("写文件出错");
    }
    return false;
    }

    /**
    * 写字串到文件中,若文件不存在,则建立新文件
    *
    * @param file
    * 需要写的文件的路径
    * @param data
    * 需要写入的字串
    * @return true:写入成功 false:写入失败
    */
    public static boolean writeToFile(String file, String data) {
    return writeToFile(file, data, "GBK");
    }

    /**
    * 写字串到文件中,若文件不存在,则建立新文件
    *
    * @param file
    * 需要写的文件的路径
    * @param data
    * 需要写入的字串
    * @param dncoding
    * 文件编码,默认为GBK
    * @return true:写入成功 false:写入失败
    */
    public static boolean writeToFile(String file, String data, String encoding) {
    try {
    if (encoding == null || "".equals(encoding)) {
    encoding = "GBK";
    }
    org.apache.commons.io.FileUtils.writeStringToFile(new File(file), data, encoding);
    return true;
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("写文件出错");
    }
    return false;
    }

    /**
    * 建立由filePathName指定的文件,若文件路径中的目录不存在,则先建立目录
    *
    * @param filePathName
    * 文件路径全名
    * @return
    */
    public static boolean createNewFile(String filePathName) {
    String filePath = FileHelper.getFullPath(filePathName);
    // 若目录不存在,则建立目录
    if (!FileHelper.exists(filePath)) {
    if (!createDirectory(filePath)) {
    return false;
    }
    }

    try {
    File file = new File(filePathName);
    return file.createNewFile();
    } catch (IOException ex) {
    ex.printStackTrace();
    System.err.println("创建文件出错");
    return false;
    }
    }

    /**
    * 判断文件和目录是否已存在
    *
    * @param filePath
    * 文件和目录完整路径
    * @return tru:存在 false:不存在
    */
    public static boolean exists(String filePath) {
    File file = new File(filePath);
    return file.exists();
    }

    /**
    * 判断特定的路径是否为文件
    *
    * @param filePath
    * 文件完整的路径
    * @return 若是文件,则返回true,否则返回false
    */
    public static boolean isFile(String filePath) {
    File file = new File(filePath);
    return file.isFile();
    }

    /**
    * 判断特定的路径是否为目录
    *
    * @param filePath
    * 文件完整的路径
    * @return 若是目录,则返回true,否则返回false
    */
    public static boolean isDirectory(String filePath) {
    File file = new File(filePath);
    return file.isDirectory();
    }

    /**
    * 更改文件的名称,若不在同一个目录下,则系统会移动文件
    *
    * @param srcFile
    * 源文件路径名称
    * @param destFile
    * 目的文件路径名称
    * @return
    */
    public static boolean renameTo(String srcFile, String destFile) {
    File file = new File(srcFile);
    return file.renameTo(new File(destFile));
    }

    /**
    *
    * 描述:根据document生成Xml文件 作者:刘宝 时间:Jun 9, 2010 3:16:11 PM
    *
    * @param fileName
    * 生成文件的路径
    * @param document
    * @param encoding
    * 编码格式
    * @return
    */
    public static boolean WriteToXMLFile(String fileName, Document document, String encoding) {
    createNewFile(fileName);
    boolean success = false;
    /** 格式化输出,类型IE浏览一样 */
    OutputFormat format = OutputFormat.createPrettyPrint();
    /** 指定XML编码 */
    format.setEncoding(encoding);
    XMLWriter writer = null;
    try {
    /** 将document中的内容写入文件中 */
    writer = new XMLWriter(new FileOutputStream(new File(fileName)), format);
    writer.write(document);
    writer.flush();
    success = true;
    /** 执行成功,需返回true */
    } catch (Exception ex) {
    ex.printStackTrace();
    System.err.println("写文件出错");
    } finally {
    if (writer != null) {
    try {
    writer.close();
    writer = null;
    } catch (IOException e) {
    e.printStackTrace();
    System.err.println("Convert code Error");
    }
    }
    }
    return success;
    }

    /**
    * 获取文件的后缀名并转化成大写
    *
    * @param fileName
    * 文件名
    * @return
    */
    public String getFileSuffix(String fileName) throws Exception {
    return fileName.substring(fileName.lastIndexOf(".") + 1,
    fileName.length()).toUpperCase();
    }

    /**
    * 创建多级目录
    *
    * @param path
    * 目录的绝对路径
    */
    public void createMultilevelDir(String path) {
    try {
    StringTokenizer st = new StringTokenizer(path, "/");
    String path1 = st.nextToken() + "/";
    String path2 = path1;
    while (st.hasMoreTokens()) {

    path1 = st.nextToken() + "/";
    path2 += path1;
    File inbox = new File(path2);
    if (!inbox.exists())
    inbox.mkdir();

    }
    } catch (Exception e) {
    System.out.println("目录创建失败" + e);
    e.printStackTrace();
    }

    }

    /**
    * 删除文件/目录(递归删除文件/目录)
    *
    * @param path
    * 文件或文件夹的绝对路径
    */
    public void deleteAll(String dirpath) {
    if (dirpath == null) {
    System.out.println("目录为空");
    } else {
    File path = new File(dirpath);
    try {
    if (!path.exists())
    return;// 目录不存在退出
    if (path.isFile()) // 如果是文件删除
    {
    path.delete();
    return;
    }
    File[] files = path.listFiles();// 如果目录中有文件递归删除文件
    for (int i = 0; i < files.length; i++) {
    deleteAll(files[i].getAbsolutePath());
    }
    path.delete();

    } catch (Exception e) {
    System.out.println("文件/目录 删除失败" + e);
    e.printStackTrace();
    }
    }
    }

    /**
    * 文件/目录 重命名
    *
    * @param oldPath
    * 原有路径(绝对路径)
    * @param newPath
    * 更新路径
    * @author lyf 注:不能修改上层次的目录
    */
    public void renameDir(String oldPath, String newPath) {
    File oldFile = new File(oldPath);// 文件或目录
    File newFile = new File(newPath);// 文件或目录
    try {
    boolean success = oldFile.renameTo(newFile);// 重命名
    if (!success) {
    System.out.println("重命名失败");
    } else {
    System.out.println("重命名成功");
    }
    } catch (RuntimeException e) {
    e.printStackTrace();
    }

    }

    /**
    * 新建目录
    */
    public static boolean newDir(String path) throws Exception {
    File file = new File(path);
    return file.mkdirs();//创建目录
    }

    /**
    * 删除目录
    */
    public static boolean deleteDir(String path) throws Exception {
    File file = new File(path);
    if (!file.exists())
    return false;// 目录不存在退出
    if (file.isFile()) // 如果是文件删除
    {
    file.delete();
    return false;
    }
    File[] files = file.listFiles();// 如果目录中有文件递归删除文件
    for (int i = 0; i < files.length; i++) {
    deleteDir(files[i].getAbsolutePath());
    }
    file.delete();

    return file.delete();//删除目录
    }

    /**
    * 更新目录
    */
    public static boolean updateDir(String path, String newPath) throws Exception {
    File file = new File(path);
    File newFile = new File(newPath);
    return file.renameTo(newFile);
    }

    // 删除文件夹
    // param folderPath 文件夹完整绝对路径
    public static void delFolder(String folderPath) {
    try {
    delAllFile(folderPath); // 删除完里面所有内容
    String filePath = folderPath;
    filePath = filePath.toString();
    java.io.File myFilePath = new java.io.File(filePath);
    myFilePath.delete(); // 删除空文件夹
    } catch (Exception e) {
    e.printStackTrace();
    }
    }

    // 删除指定文件夹下所有文件
    // param path 文件夹完整绝对路径
    public static boolean delAllFile(String path) {
    boolean flag = false;
    File file = new File(path);
    if (!file.exists()) {
    return flag;
    }
    if (!file.isDirectory()) {
    return flag;
    }
    String[] tempList = file.list();
    File temp = null;
    for (int i = 0; i < tempList.length; i++) {
    if (path.endsWith(File.separator)) {
    temp = new File(path + tempList[i]);
    } else {
    temp = new File(path + File.separator + tempList[i]);
    }
    if (temp.isFile()) {
    temp.delete();
    }
    if (temp.isDirectory()) {
    delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
    delFolder(path + "/" + tempList[i]);// 再删除空文件夹
    flag = true;
    }
    }
    return flag;
    }




    public static void main(String d[]) throws Exception{
    //deleteDir("d:/ff/dddf");
    updateDir("D:\TOOLS\Tomcat 6.0\webapps\BCCCSM\nationalExperiment/22222", "D:\TOOLS\Tomcat 6.0\webapps\BCCCSM\nationalExperiment/224222");
    }

    }
    --------------------- 

  • 相关阅读:
    Codeforces 992C(数学)
    Codeforces 990C (思维)
    Codeforces 989C (构造)
    POJ 1511 Invitation Cards(链式前向星,dij,反向建边)
    Codeforces 1335E2 Three Blocks Palindrome (hard version)(暴力)
    POJ 3273 Monthly Expense(二分)
    POJ 2566 Bound Found(尺取前缀和)
    POJ 1321 棋盘问题(dfs)
    HDU 1506 Largest Rectangle in a Histogram(单调栈)
    POJ 2823 Sliding Window(单调队列)
  • 原文地址:https://www.cnblogs.com/hyhy904/p/10947571.html
Copyright © 2011-2022 走看看