小工具大智慧—— 文件名批量转换工具

小工具大智慧—— 文件名批量转换工具

小工具大智慧

—— 文件名批量转换工具

顺利

关键字

李顺利,文件,名,文件夹,工厂模式,策略模式,数字,大小写,转换,大写转小写,小写转大写,批量,前缀,后缀,替换,Window Builder

正文

说大智慧是不是有点自大，今天就当一次标题D了。

有的时候，会碰到类似的文件或文件夹，但是它的名字是中文的数字，这在window 系统中难于排序（至少我没找到），就有这样的需求，把数字大写转换成小写，这样方便排序好阅读。

或者有的时候，你需要批量在文件夹或文件加上(修改)前缀或者后缀文字，来显示版权信息什么的，或者有的时候，需要批量修改文件的类型，基于其它某某种种的需求，在空闲时间内写了这个小工具，希望大家喜欢。

转换需求

1.支持大写转小写和小写转大写，前缀和后缀的添加或修改，字符串修改

2.转换实例

2.1大写转小写（可以处理中文中夹杂数字的情况）

第一讲 -> 第1讲

第十课 -> 第10课

十二章 -> 12章

三十 -> 30

一百四十二 -> 42

一百零二点二五 -> 102.25

2.2 小写转大写 （相对上面而言）

1 -> 一

10 -> 十

12 -> 十二

30 -> 三十

142 -> 一百四十二

102.25 -> 一百零二点二五

（主要十位数在我们习惯说十几而不是一十几,小数点后数字一一读出；上面大小写数字都可以使用字符串来处理，并且出现这些数字的时候，可能会出现其他的字符串，例如：第一讲）

2.3 前缀转换

xxx.rar -> [李顺利]xxx.rar(rule:"","[李顺利]")

[lishunli]xxx.rar -> [李顺利]xxx.rar(rule:"[lishunli]","[李顺利]")

[lishunli]xxx.rar -> xxx.rar(rule:"[lishunli]","")

2.4后缀转换

xxx.rar -> xxx[李顺利].rar(rule:"","[李顺利]")

xxx[lishunli].rar -> xxx[李顺利].rar(rule:"[lishunli]","[李顺利]")

xxx[lishunli].rar -> xxx.rar(rule:"[lishunli]","")

2.5字符串修改

123.rar ->李顺利.rar(rule:"123","李顺利")

开发环境

Eclipse + JDK 1.6 + Window Builder

小工具的优缺点

亮点

0.功能就是亮点，找了好久，真的没有相应的软件或者工具可以使用，所以就自己写了个

1.使用了工厂和策略模式

2.批量转换是对路径所有的文件夹和文件，支持迭代递归功能（也可以选择不转换文件夹）

3.其它（期待您的发现，譬如说可以批量修改文件的后缀，显示目录里面的文件名字啊...）

缺点

不支持正则表达式的替换（实际上如果你有兴趣的话也可以在这个的基础上进心加工，代码开源，可以下载或者 checkout），正则这块是我的痛啊，太不熟悉了，有时间，好好 follow 一下。

是否支持单文件操作，目前是批处理文件夹及其子文件夹内的文件？

是否需要保存上一次的配置参数？

是否支持正则表达式的匹配和修改？

部分代码

Rule的工厂类

package org.usc.file.operater.rules; 
/** 
 * 转换工厂 
 * 
 * @author <a href="http://www.blogjava.net/lishunli/" target="_blank">ShunLi</a> 
 * @notes Created on 2010-12-11<br> 
 * Revision of last commit:$Revision: 767 $<br> 
 * Author of last commit:$Author: [email protected] $<br> 
 * Date of last commit:$Date: 2010-12-12 00:17:34 +0800 (周日, 12 十二月 2010) $<br> 
 * <p> 
 */
public class ConvertFactory { 
 public static ConvertRule createConvertRule(Rule rule) { 
 ConvertRule cr = new SmallToBigConvertRule(); // Default 
 if (Rule.SmallToBig == rule) { 
 cr = new SmallToBigConvertRule(); 
 } else if (Rule.BigToSmall == rule) { 
 cr = new BigToSmallConvertRule(); 
 // cr = new SimpleBigToSmallConvertRule(); // simple 支持百一下的文件，快速一点 
 } else if (Rule.Prefix == rule) { 
 cr = new PrefixConvertRule(); 
 } else if (Rule.Suffix == rule) { 
 cr = new SuffixConvertRule(); 
 } else if (Rule.Replace == rule) { 
 cr = new ReplaceConvertRule(); 
 } 
 return cr; 
 } 
} 

文件操作类

package org.usc.file.operater.utils; 
import java.io.File; 
import java.io.IOException; 
import org.apache.commons.io.FileUtils; 
import org.usc.file.operater.rules.ConvertFactory; 
import org.usc.file.operater.rules.ConvertRule; 
import org.usc.file.operater.rules.Rule; 
/** 
 * 文件操作工具 
 * 
 * @author <a href="http://www.blogjava.net/lishunli/" target="_blank">ShunLi</a> 
 * @notes Created on 2010-12-11<br> 
 * Revision of last commit:$Revision: 829 $<br> 
 * Author of last commit:$Author: [email protected] $<br> 
 * Date of last commit:$Date: 2011-04-17 16:58:13 +0800 (周日, 17 四月 2011) $<br> 
 * <p> 
 */
public class FileOperaterTool { 
 private ConvertRule convertRule; 
 private StatisticsInfo statisticsInfo; 
 public FileOperaterTool() { 
 } 
 public FileOperaterTool(Rule rule) { 
 this.init(); 
 this.convertRule = ConvertFactory.createConvertRule(rule); 
 } 
 public void init(){ 
 this.statisticsInfo = new StatisticsInfo(); 
 } 
 public StringBuffer getStatistics(){ 
 StringBuffer sb= new StringBuffer(); 
 sb.append(this.statisticsInfo.toString()); 
 return sb; 
 } 
 /** 
 * 修改path路径下所有的文件名 
 * 
 * @param path 
 */
 public String fileRename(String path, Boolean isConvertFolder) { 
 StringBuffer info = new StringBuffer(); 
 File file = new File(path); 
 String[] tempList = file.list(); 
 if (tempList != null) { 
 File temp = null; 
 if (tempList.length == 0) { 
 info.append("\"" + path + "\"路径下没有文件" + "\n"); 
 } 
 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()) { 
 this.statisticsInfo.addSumFileNum(); 
 info.append(fileRename(temp) + "\n"); 
 } 
 if (temp.isDirectory()) { 
 this.statisticsInfo.addSumFolderNum(); 
 String folderName = path + "\\" + tempList[i]; 
 info.append(fileRename(folderName, isConvertFolder)); 
 if (isConvertFolder) { 
 info.append(folderRename(folderName) + "\n\n"); 
 } 
 } 
 } 
 } else { 
 info.append("\"" + path + "\"路径不存在" + "\n"); 
 } 
 return info.toString(); 
 } 
 /** 
 * 修改path路径下所有的文件名 
 * 
 * @param path 
 */
 public String fileRename(String path, String fix, String newFix, Boolean isConvertFolder) { 
 StringBuffer info = new StringBuffer(); 
 File file = new File(path); 
 String[] tempList = file.list(); 
 if (tempList != null) { 
 File temp = null; 
 if (tempList.length == 0) { 
 info.append("\"" + path + "\"路径下没有文件" + "\n"); 
 } 
 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()) { 
 this.statisticsInfo.addSumFileNum(); 
 info.append(fileRename(temp, fix, newFix) + "\n"); 
 } 
 if (temp.isDirectory()) { 
 this.statisticsInfo.addSumFolderNum(); 
 String folderName = path + "\\" + tempList[i]; 
 info.append(fileRename(folderName, fix, newFix, isConvertFolder)); 
 if (isConvertFolder) { 
 info.append(folderRename(folderName, fix, newFix, true) + "\n\n"); 
 } 
 } 
 } 
 } else { 
 info.append("\"" + path + "\"路径不存在" + "\n"); 
 } 
 return info.toString(); 
 } 
 /** 
 * 修改文件名 
 * 
 * @param file 
 * 文件 
 * @return N/A 
 */
 private String fileRename(File file) { 
 String info = null; 
 String oldName = file.getName(); 
 String newName = this.convertRule.reNameByRule(oldName); 
 if (!oldName.equals(newName)) { 
 Boolean result = file.renameTo(new File(file.getParent() + "\\" + newName)); 
 if (!result) { 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"转换失败，请查看是否存在文件重名"; 
 } else { 
 this.statisticsInfo.addConvertFileNum(); 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"转换为\"" + file.getParent() + "\\" + newName + "\""; 
 } 
 } else { 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"不需要转换"; 
 } 
 return info; 
 } 
 /** 
 * 修改文件夹名 
 * 
 * @param file 
 * 文件夹 
 * @return String msg 
 */
 private String folderRename(String folderName) { 
 String info = null; 
 String oldPath = folderName; 
 String newPath = this.convertRule.reNameByRule(oldPath); 
 if (!oldPath.equals(newPath)) { 
 info = moveFolder(oldPath, newPath); 
 } else { 
 info = "文件夹\"" + oldPath + "\"不需要转换"; 
 } 
 return info; 
 } 
 /** 
 * 修改文件名 
 * 
 * @param file 
 * 文件 
 * @return N/A 
 */
 private String fileRename(File file, String fix, String newFix) { 
 String info = null; 
 String oldName = file.getName(); 
 String newName = this.convertRule.reNameByRule(oldName, fix, newFix); 
 if (!oldName.equals(newName)) { 
 Boolean result = file.renameTo(new File(file.getParent() + "\\" + newName)); 
 if (!result) { 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"转换失败，请查看是否存在文件重名"; 
 } else { 
 this.statisticsInfo.addConvertFileNum(); 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"转换为\"" + file.getParent() + "\\" + newName + "\""; 
 } 
 } else { 
 info = "文件\"" + file.getParent() + "\\" + oldName + "\"不需要转换"; 
 } 
 return info; 
 } 
 /** 
 * 修改文件夹名 
 * 
 * @param file 
 * 文件夹 
 * @return String msg 
 */
 private String folderRename(String folderName, String fix, String newFix, Boolean isFolder) { 
 String info = null; 
 String oldPath = folderName; 
 String newPath = this.convertRule.reNameByRule(oldPath, fix, newFix, isFolder); 
 if (!oldPath.equals(newPath)) { 
 info = moveFolder(oldPath, newPath); 
 } else { 
 info = "文件夹\"" + oldPath + "\"不需要转换"; 
 } 
 return info; 
 } 
 // ///////////////// 
 // Internal use 
 // //////////////// 
 private String moveFolder(String oldPath, String newPath) { 
 StringBuffer infos = new StringBuffer(); 
 try { 
 FileUtils.moveDirectory(new File(oldPath), new File(newPath)); 
 this.statisticsInfo.addConvertFolderNum(); 
 infos.append("文件夹\"" + oldPath + "\"转换为\"" + newPath + "\""); 
 } catch (IOException e) { 
 infos.append("文件夹\"" + oldPath + "\"转换失败，请查看是否存在文件夹重名\n"); 
 infos.append(e.getMessage()); 
 } 
 return infos.toString(); 
 } 
}

小写转换为大写，e.g. 101 -> 一百零一

package org.usc.file.operater.rules; 
import java.util.Arrays; 
import java.util.HashMap; 
import java.util.List; 
/** 
 * 小写转大写规则 
 * 
 * @author <a href="http://www.blogjava.net/lishunli/" target="_blank">ShunLi</a> 
 * @notes Created on 2010-12-11<br> 
 * Revision of last commit:$Revision: 829 $<br> 
 * Author of last commit:$Author: [email protected] $<br> 
 * Date of last commit:$Date: 2011-04-17 16:58:13 +0800 (周日, 17 四月 2011) $<br> 
 * <p> 
 */
public class SmallToBigConvertRule implements ConvertRule { 
 private static java.util.Map<String, String> SmallToBigMap = new HashMap<String, String>(); 
 static { 
 SmallToBigMap.put(String.valueOf(0), "零"); 
 SmallToBigMap.put(String.valueOf(1), "一"); 
 SmallToBigMap.put(String.valueOf(2), "二"); 
 SmallToBigMap.put(String.valueOf(3), "三"); 
 SmallToBigMap.put(String.valueOf(4), "四"); 
 SmallToBigMap.put(String.valueOf(5), "五"); 
 SmallToBigMap.put(String.valueOf(6), "六"); 
 SmallToBigMap.put(String.valueOf(7), "七"); 
 SmallToBigMap.put(String.valueOf(8), "八"); 
 SmallToBigMap.put(String.valueOf(9), "九"); 
 SmallToBigMap.put(String.valueOf(10), "十"); 
 SmallToBigMap.put(String.valueOf(100), "百"); 
 SmallToBigMap.put(String.valueOf(1000), "千"); 
 SmallToBigMap.put(String.valueOf(10000), "万"); 
 SmallToBigMap.put(String.valueOf(100000000), "亿"); 
 } 
 public static String format(String num) { 
 // 先将末尾的零去掉 
 String numString = String.valueOf(num).replaceAll("[.][0]+$", ""); 
 // 分别获取整数部分和小数部分的数字 
 String intValue; 
 String decValue = ""; 
 if (".".equals(num.trim())) { 
 return "."; 
 } else if (numString.indexOf(".") != -1) { 
 String[] intValueArray = String.valueOf(numString).split("\\."); 
 String[] decVauleArray = String.valueOf(num).split("\\."); 
 intValue = (intValueArray != null && intValueArray.length > 0 ? intValueArray[0] : "0"); 
 decValue = (decVauleArray != null && decVauleArray.length > 1 ? decVauleArray[1] : "0"); 
 } else { 
 intValue = String.valueOf(numString); 
 } 
 // 翻译整数部分。 
 intValue = formatLong(Long.parseLong(String.valueOf(intValue))); 
 // 翻译小数部分 
 decValue = formatDecnum(decValue); 
 String resultString = intValue; 
 if (!decValue.equals("")) 
 resultString = resultString + "点" + decValue; 
 return resultString.replaceAll("^一十", "十"); 
 } 
 /** 
 * 将阿拉伯整数数字翻译为汉语小写数字。 其核心思想是按照中文的读法，从后往前每四个数字为一组。每一组最后要加上对应的单位，分别为万、亿等。 每一组中从后往前每个数字后面加上对应的单位，分别为个十百千。 每一组中如果出现零千、零百、零十的情况下去掉单位。 每组中若出现多个连续的零，则通读为一个零。 
 * 若每一组中若零位于开始或结尾的位置，则不读。 
 * 
 * @param num 
 * @return 
 */
 public static String formatLong(Long num) { 
 Long unit = 10000L; 
 Long perUnit = 10000L; 
 String sb = new String(); 
 String unitHeadString = ""; 
 while (num > 0) { 
 Long temp = num % perUnit; 
 sb = formatLongLess10000(temp) + sb; 
 // 判断是否以单位表示为字符串首位，如果是，则去掉，替换为零 
 if (!"".equals(unitHeadString)) 
 sb = sb.replaceAll("^" + unitHeadString, "零"); 
 num = num / perUnit; 
 if (num > 0) { 
 // 如果大于当前单位，则追加对应的单位 
 unitHeadString = SmallToBigMap.get(String.valueOf(unit)); 
 sb = unitHeadString + sb; 
 } 
 unit = unit * perUnit; 
 } 
 return sb == null || sb.trim().length() == 0 ? "零" : sb; 
 } 
 /** 
 * 将小于一万的整数转换为中文汉语小写 
 * 
 * @param num 
 * @return 
 */
 public static String formatLongLess10000(Long num) { 
 StringBuffer sb = new StringBuffer(); 
 for (Long unit = 1000L; unit > 0; unit = unit / 10) { 
 Long _num = num / unit; 
 // 追加数字翻译 
 sb.append(SmallToBigMap.get(String.valueOf(_num))); 
 if (unit > 1 && _num > 0) 
 sb.append(SmallToBigMap.get(String.valueOf(unit))); 
 num = num % unit; 
 } 
 // 先将连续的零联合为一个零，再去掉头部和末尾的零 
 return sb.toString().replaceAll("[零]+", "零").replaceAll("^零", "").replaceAll("零$", ""); 
 } 
 public static String formatDecnum(String num) { 
 StringBuffer sBuffer = new StringBuffer(); 
 char[] chars = num.toCharArray(); 
 for (int i = 0; i < num.length(); i++) { 
 sBuffer.append(SmallToBigMap.get(String.valueOf(chars[i]))); 
 } 
 return sBuffer.toString(); 
 } 
 public static String parseString(String oldName) { 
 String[] str = new String[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "." }; 
 List<String> num = Arrays.asList(str); 
 StringBuffer stringBuffer = new StringBuffer(); 
 int index = oldName.lastIndexOf("\\"); 
 if (index != -1) { 
 stringBuffer.append(oldName.substring(0, index + 1)); 
 oldName = oldName.substring(index + 1); 
 } 
 StringBuffer numBuffer = new StringBuffer(); 
 for (int i = 0; i < oldName.length(); i++) { 
 if (num.contains(oldName.substring(i, i + 1))) { 
 numBuffer.append(oldName.substring(i, i + 1)); 
 } else { 
 if (numBuffer != null && numBuffer.length() > 0) { 
 String convertTemp = numBuffer.toString(); 
 // 去掉最后的小数点 
 if(convertTemp.endsWith(".") && !".".equals(convertTemp)){ 
 convertTemp = convertTemp.substring(0,convertTemp.length()-1); 
 stringBuffer.append(format(convertTemp)).append("."); 
 }else{ 
 stringBuffer.append(format(convertTemp)); 
 } 
 numBuffer.delete(0, numBuffer.length()); 
 } else { 
 stringBuffer.append(numBuffer.toString()); 
 numBuffer.delete(0, numBuffer.length()); 
 } 
 stringBuffer.append(oldName.substring(i, i + 1)); 
 } 
 } 
 if (numBuffer != null && numBuffer.length() > 0 && numBuffer.indexOf(".") == -1) { 
 stringBuffer.append(format(numBuffer.toString())); 
 } else { 
 stringBuffer.append(numBuffer.toString()); 
 } 
 return stringBuffer.toString(); 
 } 
 @Override 
 public String reNameByRule(String oldName) { 
 return parseString(oldName); 
 } 
 @Override 
 public String reNameByRule(String oldName, String fix, String newFix) { 
 return reNameByRule(oldName); 
 } 
 @Override 
 public String reNameByRule(String oldName, String fix, String newFix, Boolean isFolder) { 
 return reNameByRule(oldName); 
 } 
} 

大写转换成小写， e.g. 十 –>10

package org.usc.file.operater.rules; 
import java.util.HashMap; 
import java.util.Map; 
/** 
 * 大写转小写规则 
 * 
 * @author <a href="http://www.blogjava.net/lishunli/" target="_blank">ShunLi</a> 
 * @notes Created on 2010-12-11<br> 
 * Revision of last commit:$Revision: 829 $<br> 
 * Author of last commit:$Author: [email protected] $<br> 
 * Date of last commit:$Date: 2011-04-17 16:58:13 +0800 (周日, 17 四月 2011) $<br> 
 * <p> 
 */
public class BigToSmallConvertRule implements ConvertRule { 
 private static Map<String, Long> numberMap = new HashMap<String, Long>(); 
 private static Map<String, Long> unitMap = new HashMap<String, Long>(); 
 private static Map<String, Long> levelMap = new HashMap<String, Long>(); 
 private static Map<String, Long> upperLevelMap = new HashMap<String, Long>(); 
 static { 
 numberMap.put("零", 0L); 
 numberMap.put("一", 1L); 
 numberMap.put("二", 2L); 
 numberMap.put("三", 3L); 
 numberMap.put("四", 4L); 
 numberMap.put("五", 5L); 
 numberMap.put("六", 6L); 
 numberMap.put("七", 7L); 
 numberMap.put("八", 8L); 
 numberMap.put("九", 9L); 
 numberMap.put("十", 10L); 
 unitMap.put("十", 10L); 
 unitMap.put("百", 100L); 
 unitMap.put("千", 1000L); 
 unitMap.put("万", 10000L); 
 unitMap.put("亿", 100000000L); 
 levelMap.put("万", 10000L); 
 levelMap.put("亿", 100000000L); 
 upperLevelMap.put("亿", 100000000L); 
 } 
 @Override 
 public String reNameByRule(String oldName) { 
 Long sum = 0L; 
 StringBuffer newName = new StringBuffer(); 
 int index = oldName.lastIndexOf("\\"); 
 if (index != -1) { 
 newName.append(oldName.substring(0, index + 1)); 
 oldName = oldName.substring(index + 1); 
 } 
 int size = oldName.length(); 
 for (int i = 0; i < size; i++) { 
 Boolean flag = false; 
 if (numberMap.keySet().contains(oldName.substring(i, i + 1))) { 
 Long small = numberMap.get(oldName.substring(i, i + 1)); 
 Long big = 1L; 
 if ((i + 1 < size) && unitMap.keySet().contains(oldName.substring(i + 1, i + 2))) { 
 big = unitMap.get(oldName.substring(i + 1, i + 2)); 
 if ("万".equals(oldName.substring(i + 1, i + 2)) || "亿".equals(oldName.substring(i + 1, i + 2))) { 
 small += sum; 
 sum = 0L; 
 } 
 if ((i + 2 < size) && levelMap.keySet().contains(oldName.substring(i + 2, i + 3))) { 
 small = small * big; 
 big = levelMap.get(oldName.substring(i + 2, i + 3)); 
 if ((i + 3 < size) && upperLevelMap.keySet().contains(oldName.substring(i + 3, i + 4))) { 
 small = small * big; 
 big = upperLevelMap.get(oldName.substring(i + 3, i + 4)); 
 i++; 
 } 
 i++; 
 } 
 i++; 
 } 
 sum = sum + small * big; 
 flag = true; 
 } 
 if (!flag) { 
 if (sum != 0) { 
 newName.append(sum.toString()); 
 } 
 newName.append(oldName.substring(i, i + 1)); 
 sum = 0L; 
 } else { 
 if (sum == 0 && "零".equals(oldName.substring(i, i + 1))) { 
 newName.append(sum.toString()); 
 } 
 } 
 } 
 if (sum != 0) { 
 newName.append(sum.toString()); 
 } 
 return newName.toString(); 
 } 
 @Override 
 public String reNameByRule(String oldName, String fix, String newFix) { 
 return reNameByRule(oldName); 
 } 
 @Override 
 public String reNameByRule(String oldName, String fix, String newFix, Boolean isFolder) { 
 return reNameByRule(oldName); 
 } 
} 

运行环境

Jdk1.6(不知道支持1.5？用1.6写的)，虽然提供的小工具为了方便打包成.exe 发布，但必须安装JDK了，非java 使用者就只能 say sorry 了。

建议分辨率为1280*1024

最低分辨率为1024*768

程序截图

下载和源码

源码下载（包括测试样例和运行程序）

文 件 名：FileNameBatchConvert.zip
下载地址：http://usc.googlecode.com/files/FileNameBatchConvert.zip

源代码checkout(SVN，建议使用，保持最新的代码)

http://usc.googlecode.com/svn/FileNameBatchConvert/

工具下载

文 件 名：文件名批量转换V2.1.exe
下载地址：http://usc.googlecode.com/files/%E6%96%87%E4%BB%B6%E5%90%8D%E6%89%B9%E9%87%8F%E8%BD%AC%E6%8D%A2V2.1.exe

Bug跟踪

如果发现了问题，您如果没有兴趣或者没有时间不用管，顺利很抱歉为您带来了麻烦，不过您也可以尝试自己解决，当然非常欢迎告知在下。

尾声

实际上写这篇文章是练练手，熟悉下Java的一些基础知识，不要一来就是 SSH ，实际上真正地开发是业务知识第一，Java就是第二（真的吗？至少我目前认为不是，不过前人都是这么说，引用下，这里），后面才是学习新技术的能力（个人愚见）。

实际上，这个工具也没啥，就是调用一些File 类的API，进行封装而已，可能这个工具不太实用，不过也没什么，至少我用的很ok，那就行了。后续的想法是迁移到Maven项目，更多的使用 Apache common utils，比如 FileUtil，FileNameUtil，如果能支持正则就非常完美了。

如果有什么建议或意见可以通过微博 http://weibo.com/lishunli（左上侧直接加关注）或QQ：506817493（QQ白天经常不在线，建议微博交流，谢谢），大家一起交流学习。

最后弱弱地说一下，如果可以的话，转载请提供原URL。谢谢

顺利

2011年8月13日

版本更新信息

Version

V3.0

还没有完成的，大致的想法是迁移到Maven项目，更多的使用 Apache common utils，比如 FileUtil，FileNameUtil，如果能支持正则就非常完美了。

V2.1

1.性能优化，使用 commons-io 的 FileUtils 来进行move整个文件夹的操作;

2.封装计数的结果。

V2.0版本新特性

1.优化UI布局

2.该用WindowBuilder Pro(Google)设计UI

3.增加转换参数选项

4.增加导出转换结果信息为文本文件功能

5.增加打开转换结果信息文本文件功能

6.增加按钮可单击性控制

7.增加控件的提示信息

8.修改默认的程序图标

V2.0.0.1

Tuning UI:

1. 默认不选择任何转换规则 - Default Set don't check any rules.

2. 复制的路径也保存到注册表中 - Filepath by manual copy is also saved to the registry path.

V2.1.0.0

1.性能优化，使用 commons-io 的 FileUtils 来进行move整个文件夹的操作;

2.封装计数的结果。

-- EN --

1. Performance Tuning,use commons-io's File utils to move folder.

2. Encapsulation and abstraction.

版本更改其它Log

结果显示增加时间统计

初步完成V0.2版，增加文件夹浏览，清空结果等功能。

加入窗体图标；

制作Exe文件

v0.3:添加对前后缀文件名的批量修改

1.修改checkbox 选中与不选中时的处理；

2.V0.3完成；

3.准备完成V1.0版，增加字符串修改。

修正UI上面单击可能没有反应的Bug;

修正提示信息。

增加文件夹是否转换？功能;

修正对文件夹替换字符串的Bug.

虽然改动很小，但是解决了一个很实用的Bug

就是在字符串replace的时候是使用的正则表达式，传过来的字符串中可能存在正则表达式的特殊字符，例如'[','(' and so on

通过使用Pattern.quote来获得 a literal String.

出现了在windows中文件名不能输入一些特殊字符的Bug

文件名不能包含下列任何字符:

\/:*?"<>|

v1.0不处理，以出错信息结束；

v1.1做过滤处理。

创建V1.1,出现特殊字符的时候，过滤它们；

修正原串为“”的情况下出现的Bug.

记住上一次打开的路径；

修改显示的结果信息。

修改为版本V1.2;

默认不转换文件夹（真正的多层转换很少）

修改结果信息的显示

可以选择是否显示更多转换信息（默认不显示，更简洁）

增加转换和成功转换文件夹和文件统计数目信息

博客中的一些下载已经放到了百度云了，请根据需要下载。 【点我去百度云下载】

最后弱弱地说一下，如果可以的话，转载请提供出处( )，谢谢。