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

最新推荐文章于 2025-08-14 18:11:10 发布

iteye_887

最新推荐文章于 2025-08-14 18:11:10 发布

阅读量198

点赞数

文章标签： ui java 开发工具

转换需求

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: nhjsjmz@gmail.com $<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: nhjsjmz@gmail.com $<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: nhjsjmz@gmail.com $<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: nhjsjmz@gmail.com $<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 ，如果能支持正则就非常完美了。