java常用工具类 IP、File文件工具类

本文实例为大家分享了java常用工具类的具体实现代码，供大家参考，具体内容如下

ip工具类

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;
 }

}

file文件工具类

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"); 
 } 
  
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。