【技术碎片】重名文件后缀重命名方法

已于 2023-12-17 14:31:08 修改
阅读量696 收藏
点赞数
分类专栏： # 技术碎片 项目 文章标签： java 开发语言
于 2022-06-08 22:38:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fisherish/article/details/125188698
版权

在这里插入图片描述

目录

重名文件 加后缀重命名过滤实现

重名文件加后缀重命名过滤

如果存在重名，则在后面（扩展名的前面）加后缀 “_1”, “_2”, “_3”, … 直到文件名不重复为止，以此来确保文件名的唯一性。

实现

public class Main {

    public static void main(String[] args) {
        String originalFileName = "1232121421412(0).jpg";

        Boolean repeat = true;
        // 文件是否存在重名
        StringBuilder fileName = new StringBuilder();

        // 如果存在重名，则加_1后缀
        if (repeat) {
            int suffixNumber = 0;
            String fileExtensionName = "";

            // 分离文件拓展名(.jpg .png ... )
            for (int i = originalFileName.length() - 1; i > 0; i--) {
                if (originalFileName.charAt(i) == '.') {
                    fileExtensionName = originalFileName.substring(i, originalFileName.length());
                    fileName = new StringBuilder(originalFileName.substring(0, i));
                    break;
                }
            }

            // 加_1后缀
            fileName.append("_" + ++suffixNumber);
            // 如果已经存在 _1 后缀，则改为 _2 , _3 ,...直到不重复为止
            while (repeat) {
                // 把我们添加的"_"后面所有数字字符删除
                for (int length = fileName.length(); length > 0; length--) {
                    char c = fileName.charAt(length - 1);
                    if (c != '_') {
                        fileName.delete(length - 1, length);
                    }
                    else {
                        break;
                    }
                }
                fileName.append(++suffixNumber);

                // 假设_23时不再重复
                if ("23".equals(fileName.substring(fileName.length() - 2, fileName.length()))) {
                    break;
                }
            }
            // 合并扩展名后返回
            fileName.append(fileExtensionName);
            System.out.println(fileName);
        }

    }

}

步骤概要：

  1. 定义原始文件名 originalFileName，并假设存在文件重名的情况（repeat 设置为 true）。
  2. 创建 StringBuilder 对象 fileName 用于存储新的文件名。代码找到原始文件名中的文件扩展名（如 .jpg、.png ）。这通过从后向前遍历字符串，当遇到第一个.字符时截取扩展名并分离出来。
  3. 初始化一个整数变量 suffixNumber 用于存储后缀编号，初始值为0。
  4. 接下来开始处理重名问题。首先在文件名后添加 _1 后缀。
  5. 然后循环，检查新生成的文件名是否仍然存在重名。如果存在将继续增加后缀编号。
  6. 在循环中，首先删除之前添加的 _ 及其后面的所有数字字符。然后将 suffixNumber 加一，并重新添加到文件名后。
  7. 假设在某一时刻（如 “_23”），文件名不再重复，此时跳出循环。
  8. 将分离出来的文件扩展名添加回新的文件名。输出最终的新文件名。

运行

在这里插入图片描述

基于指数扩散二分搜索的重名文件重命名后缀

一般我们在重命名文件时可以发现是这种结构：

test.txt
test_1.txt
test_2.txt

或者是：

test.txt
test(1).txt
test(2).txt

前者是linux，后者是windows系统，但是不管什么系统，其核心逻辑都是通过在后缀中添加数字来实现的，首先可以想到的是数字应该从1开始计数（原文件则代表0），并且逐渐递增，我们先有线性搜索：

linearSearch

    /**
     * 线性查找
     * @param originalFileName
     * @return long
     */
    public static long linearSearch(String originalFileName) {
        long start = System.currentTimeMillis();

        Boolean repeat = true;

        // 如果存在重名，则加(1)后缀
        if (repeat) {
            StringBuilder fileName = new StringBuilder();
            // 后缀数字初始化
            int suffixNumber = 0;
            String fileExtensionName = "";

            // 分离文件拓展名(.jpg .png ... )
            for (int i = originalFileName.length() - 1; i > 0; i--) {
                if (originalFileName.charAt(i) == '.') {
                    fileExtensionName = originalFileName.substring(i, originalFileName.length());
                    fileName = new StringBuilder(originalFileName.substring(0, i));
                    break;
                }
            }
            // 加_1后缀
            fileName.append("_" + ++suffixNumber);
            repeat = true;

            // 如果已经存在 _1 后缀，则改为 _2 , _3 ,...直到不重复为止
            while (repeat) {
                // 把我们添加的"_"后面所有数字字符删除
                for (int length = fileName.length(); length > 0; length--) {
                    char c = fileName.charAt(length - 1);
                    if (c != '_') {
                        fileName.delete(length - 1, length);
                    } else {
                        break;
                    }
                }
                // 在"_"后面添加++suffixNumber
                fileName.append(++suffixNumber);
                // 【重复判断】模拟O(n)的全图片集扫描
                for (int i = 0; i < repeatNumberSize; i++) {
                    // 假设_repeatNumber时不再重复
                    if (repeatNumber.equals(fileName.substring(fileName.length() - repeatNumber.length(), fileName.length()))) {
                        repeat = false;
                        break;
                    }
                }
//                System.out.println(repeat + " " + fileName);
            }
            // 合并扩展名后返回
            fileName.append(fileExtensionName);
            System.out.println(fileName);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }

exponentialDiffusionBinarySearch

我们有指数扩散二分查找：

    /**
     * 指数扩散二分查找
     * @param originalFileName
     * @return long
     */
    public static long exponentialDiffusionBinarySearch(String originalFileName) {
        long start = System.currentTimeMillis();

        Boolean repeat = true;

        // 如果存在重名，则加(1)后缀
        if (repeat) {
            StringBuilder fileName = new StringBuilder();
            // 后缀数字初始化
            int suffixNumber = 0;
            String fileExtensionName = "";

            // 分离文件拓展名(.jpg .png ... )
            for (int i = originalFileName.length() - 1; i > 0; i--) {
                if (originalFileName.charAt(i) == '.') {
                    fileExtensionName = originalFileName.substring(i, originalFileName.length());
                    fileName = new StringBuilder(originalFileName.substring(0, i));
                    break;
                }
            }
            // 加_1后缀
            fileName.append("_" + ++suffixNumber);
            repeat = true;

            int left = 1;
            int mid = 1;
            int right = 2;
            boolean rightFind = repeat;

            // 1.指数扩散，右边界扩散至无目标区
            while (rightFind) {
                // 左边界跟进，缩小范围
                left = mid;
                // 右边界指数扩张，继续搜索
                right = right * 2;
                // 二分法试探
                mid = (left + right) / 2;
                // 【判断重复】假设_right下标不再重复
                if (repeatNumberSize < right) {
                    rightFind = false;
                }
            }

            // 【判断重复】
            repeat = (mid < repeatNumberSize) ? true : false;
            // 2.二分查找
            while (repeat.equals(Boolean.TRUE) || left < right) {
                // 把我们添加的"_"后面所有数字字符删除
                for (int length = fileName.length(); length > 0; length--) {
                    char c = fileName.charAt(length - 1);
                    if (c != '_') {
                        fileName.delete(length - 1, length);
                    } else {
                        break;
                    }
                }

                if (repeat) {
                    // 左边界跟进，缩小范围
                    left = mid + 1;
                }
                else {
                    // 右边界收回，缩小范围
                    right = mid;
                }
                // 二分法试探
                mid = (left + right) / 2;

                // 在"_"后面添加 mid
                fileName.append(mid);
                // 模拟O(n)的全图片集扫描，【判断重复】
                for (int i = 0; i < repeatNumberSize; i++) {
                    // 假设_repeatNumber时不再重复
                    if (mid < repeatNumberSize) {
                        repeat = true;
                        break;
                    }
                    else if (repeatNumberSize <= mid) {
                        repeat = false;
                        break;
                    }
                }

//                System.out.println(repeat + " " + fileName);
            }
            // 合并扩展名后返回
            fileName.append(fileExtensionName);
            System.out.println(fileName);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }

代码概要：

  1. 假设存在文件重名的情况：将布尔变量 repeat 设置为 true。
  2. 如果存在重名，执行以下操作：初始化一个 StringBuilder 对象 fileName。初始化后缀数字 suffixNumber 为0。
  3. 找到原始文件名中的文件扩展名，并将其存储在 fileExtensionName 中。在文件名后添加 (1) 后缀。
  4. 初始化二分查找的相关变量：left、mid 和 right 分别设置为1，rightFind 设置为 repeat 的值。
  5. 使用指数扩散的方法来确定右边界：在循环中，每次都将右边界扩大两倍（right *= 2）。使用二分法更新 mid 的值。
  6. 检查是否找到了无目标区域（即不存在重复的后缀），如果找到，则跳出循环。
  7. 判断是否存在重复后缀：根据 mid 和 repeatNumberSize 的关系来判断是否存在重复。如果存在重复，将 repeat 设置为 true，否则设置为 false。使用二分查找来寻找唯一的后缀编号：
  8. 在循环中，根据 repeat 的值更新左边界或右边界。更新 mid 的值。删除之前添加的 _ 及其后面的所有数字字符。在文件名后添加 mid。
  9. 模拟全图片集扫描的过程，检查是否存在重复后缀。
  10. 如果找到重复后缀，将 repeat 设置为 true，否则设置为 false。
  11. 循环结束时，将分离出来的文件扩展名添加回新的文件名，并输出结果。
  12. 使用 System.currentTimeMillis() 获取当前时间并存储在变量 end 中。返回处理过程所花费的时间：计算 end 和 start 之间的差值并返回。

实现

ExponentialDiffusionBinarySearch.java

总的代码实现和demo有：


/**
 * 基于指数扩散二分查找的重名文件搜索
 * @author
 */
public class ExponentialDiffusionBinarySearch {

    public static String repeatNumber = "200";

    public static int repeatNumberSize = Integer.parseInt(repeatNumber);

    public static String originalFileName = "1232121421412(0).jpg";

    /**
     * 线性查找
     * @param originalFileName
     * @return long
     */
    public static long linearSearch(String originalFileName) {
        long start = System.currentTimeMillis();

        Boolean repeat = true;

        // 如果存在重名，则加(1)后缀
        if (repeat) {
            StringBuilder fileName = new StringBuilder();
            // 后缀数字初始化
            int suffixNumber = 0;
            String fileExtensionName = "";

            // 分离文件拓展名(.jpg .png ... )
            for (int i = originalFileName.length() - 1; i > 0; i--) {
                if (originalFileName.charAt(i) == '.') {
                    fileExtensionName = originalFileName.substring(i, originalFileName.length());
                    fileName = new StringBuilder(originalFileName.substring(0, i));
                    break;
                }
            }
            // 加_1后缀
            fileName.append("_" + ++suffixNumber);
            repeat = true;

            // 如果已经存在 _1 后缀，则改为 _2 , _3 ,...直到不重复为止
            while (repeat) {
                // 把我们添加的"_"后面所有数字字符删除
                for (int length = fileName.length(); length > 0; length--) {
                    char c = fileName.charAt(length - 1);
                    if (c != '_') {
                        fileName.delete(length - 1, length);
                    } else {
                        break;
                    }
                }
                // 在"_"后面添加++suffixNumber
                fileName.append(++suffixNumber);
                // 【重复判断】模拟O(n)的全图片集扫描
                for (int i = 0; i < repeatNumberSize; i++) {
                    // 假设_repeatNumber时不再重复
                    if (repeatNumber.equals(fileName.substring(fileName.length() - repeatNumber.length(), fileName.length()))) {
                        repeat = false;
                        break;
                    }
                }
//                System.out.println(repeat + " " + fileName);
            }
            // 合并扩展名后返回
            fileName.append(fileExtensionName);
            System.out.println(fileName);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }

    /**
     * 指数扩散二分查找
     * @param originalFileName
     * @return long
     */
    public static long exponentialDiffusionBinarySearch(String originalFileName) {
        long start = System.currentTimeMillis();

        Boolean repeat = true;

        // 如果存在重名，则加(1)后缀
        if (repeat) {
            StringBuilder fileName = new StringBuilder();
            // 后缀数字初始化
            int suffixNumber = 0;
            String fileExtensionName = "";

            // 分离文件拓展名(.jpg .png ... )
            for (int i = originalFileName.length() - 1; i > 0; i--) {
                if (originalFileName.charAt(i) == '.') {
                    fileExtensionName = originalFileName.substring(i, originalFileName.length());
                    fileName = new StringBuilder(originalFileName.substring(0, i));
                    break;
                }
            }
            // 加_1后缀
            fileName.append("_" + ++suffixNumber);
            repeat = true;

            int left = 1;
            int mid = 1;
            int right = 2;
            boolean rightFind = repeat;

            // 1.指数扩散，右边界扩散至无目标区
            while (rightFind) {
                // 左边界跟进，缩小范围
                left = mid;
                // 右边界指数扩张，继续搜索
                right = right * 2;
                // 二分法试探
                mid = (left + right) / 2;
                // 【判断重复】假设_right下标不再重复
                if (repeatNumberSize < right) {
                    rightFind = false;
                }
            }

            // 【判断重复】
            repeat = (mid < repeatNumberSize) ? true : false;
            // 2.二分查找
            while (repeat.equals(Boolean.TRUE) || left < right) {
                // 把我们添加的"_"后面所有数字字符删除
                for (int length = fileName.length(); length > 0; length--) {
                    char c = fileName.charAt(length - 1);
                    if (c != '_') {
                        fileName.delete(length - 1, length);
                    } else {
                        break;
                    }
                }

                if (repeat) {
                    // 左边界跟进，缩小范围
                    left = mid + 1;
                }
                else {
                    // 右边界收回，缩小范围
                    right = mid;
                }
                // 二分法试探
                mid = (left + right) / 2;

                // 在"_"后面添加 mid
                fileName.append(mid);
                // 模拟O(n)的全图片集扫描，【判断重复】
                for (int i = 0; i < repeatNumberSize; i++) {
                    // 假设_repeatNumber时不再重复
                    if (mid < repeatNumberSize) {
                        repeat = true;
                        break;
                    }
                    else if (repeatNumberSize <= mid) {
                        repeat = false;
                        break;
                    }
                }

//                System.out.println(repeat + " " + fileName);
            }
            // 合并扩展名后返回
            fileName.append(fileExtensionName);
            System.out.println(fileName);
        }
        long end = System.currentTimeMillis();
        return (end - start);
    }


    public static void main(String[] args) {

        long time1 = linearSearch(originalFileName);
        System.out.println("linearSearch 运行时间：" + time1 + "(ms)");

        long time2 = exponentialDiffusionBinarySearch(originalFileName);
        System.out.println("exponentialDiffusionBinarySearch 运行时间：" + time2 + "(ms)");
    }
}

运行

运行结果如下，可以看到同样是从0搜索到200的后缀名，线性搜索的重名文件重命名后缀运行耗时32ms，指数扩散二分搜索的的重名文件重命名后缀则耗时0ms，非常迅速。

在这里插入图片描述

锥栗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
工具方法：下载文件时碰到相同文件，文件名增加(1) 如果有(1)则下载文件名后缀（2）
rabbitinhere的专栏
09-19 1006
下载方法不提供，本文只提供获取尾部带（1）或（2）这种路径的方法--> String getUniquePath(String path) 其他方法都是子方法 //主方法：获取正确的文件存放路径 private static String getUniquePath(String path) { String resPath = path; File file = new F
重命名后后缀名重现
大家好，我是一个软妹子—贰小妹
08-09 249
1、第一看是否是你代码关闭了后缀名  builder.setEditTextContent(FileUtils.getLastFileName(file, true)); false（为假）是你关闭了后缀名，打开只需改为true（为真） 2、    private void renameItem(final BaseListItem item) {         final File
Java保证字符串唯一(不唯一加数字后缀)
最新发布
m0_66572126的博客
05-14 336
在Java中，如果你有一个字符串列表，并希望确保每个字符串都是唯一的，那么可以通过检查重复项并为重复的字符串添加后缀数字来实现。这种方法可以扩展到更复杂的场景，例如处理文件名、用户输入等，确保所有字符串都唯一且易于识别。- 如果在映射中，增加计数，并将计数作为后缀添加到字符串后，添加到唯一列表。- 如果不在映射中，将其添加到映射并设置计数为0，并添加到唯一列表。- 遍历输入列表：对于每个字符串，检查是否已经在映射中。- 唯一列表：用来存储处理后的唯一字符串。- 输入列表：包含可能重复的字符串。
java 文件上传名字重复后缀+1
艺艺小同学的博客
08-26 2599
校验文件名称 /** * 校验文件名称相同，若相同后缀(+n) * @param filePath 文件路径 * @param fileName 文件名称 * @return 新文件名称 */ private String checkFileName(String filePath, String fileName) { int fileMax = getFileMax(filePath, fileName); ...
java实现对重名文件加上(1)、(2)
yuhuofei的草屋
03-13 3145
java实现对重名文件自动添加(1)、(2)、(3)、(4)… /** * 有重名文件，自动在后面添加(1)、(2)、(3)... * * @param filePath 原始文件存放路径，例如D:/test/AAA.jpg * @param fileName 原始文件名，例如AAA * @param suffix 原始文件后缀，例如jpg * @param num 原始文件名小括号中的数字，如果没有，传0 * @r
文件修改操作方法：快速修改文件拓展名
candy_18的博客
01-28 417
在我们日常材料文件时有时候需要改变文件的类型、满足特定需求或与特定软件兼容。我们就需要修改文件的类型是十分麻烦的事情，这个时候我们就需要用到“天图文件管理”来帮助我们快速修改文件拓展名。通过以上方法，你可以快速修改文件的拓展名，满足不同的需求和用途。3、全部添加完成后，我们先在新文件名称中选择“原文件名称”再在扩展名中选择“自定义”输入我们需要修改的文件拓展名。1、我们打开“天图文件管理工具”选择“文件批量重命名”功能界面。2、我们点击“添加文件”把需要的文件素材进行添加。
java 文件名或扩展名太长_Android项目在debug时因文件名或扩展名太长build失败，如何解决？...
weixin_31550647的博客
03-05 898
问题描述一个安卓项目，和别人相同的代码，在别人的电脑上运行正常，在我这边点击debug后，build失败。问题出现的环境背景及自己尝试过哪些方法Android Studio版本：3.4.2操作系统：WindowsGradle版本：2.3.3根据Android studio CreateProcess error=206, 文件名或扩展名太长 解决方案，将项目移动到E盘根目录下，然而仍然失败，路径已...
批量文件后缀重命名工具
05-01
批量文件后缀重命名工具是一种实用程序，专为IT专业人士和普通用户设计，旨在高效地管理大量文件，尤其是需要更改其扩展名的情况。在日常工作中，我们可能遇到需要统一更新文件扩展名的需求，例如在转换文件格式、...
批量文件重命名工具.zip
08-19
5. **安全措施**：优秀的批量重命名工具还会提供防止重名冲突的机制，如果新名称已存在，会自动调整以避免覆盖其他文件。 批量文件重命名工具是提高工作效率的重要工具，尤其对于那些需要定期整理大量文件的用户，...
C#实现保存文件时重名自动生成新文件的方法
12-30
本文实例讲述了C#实现保存文件时重名自动生成新文件的方法。分享给大家供大家参考。具体如下： 将一个文档保存为 a.txt 时，发现此文件已经存在，则自动保存为 a(1).txt /// /// Generates a new path for ...
文件批量重命名工具
10-28
7. **安全机制**：在重命名过程中，工具应具备防止重复文件名的机制，以防止因重名导致的数据覆盖。 8. **兼容性**：本工具标记为“window”，意味着它主要适用于Windows操作系统，可能无法在其他如Mac OS或Linux...
批量文件名加后缀
08-05
如题运行的时候必须保证要重命名的文件和它在同一目录
Android给文件改后缀名
gx251zyb的博客
08-27 5855
java ,android文件改名       这里renameFile有两个参数,第一个参数当前需要改名的文件路径例如：String fliepath = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "Download"+ File.separator + "f.zip" 第二个
JAVA中使用split获取文件的后缀
weixin_45837726的博客
07-23 195
给定文件名：“image.txt”需要获取它的.txt后缀。
android / java 列出文件夹下指定扩展名的文件名
whunamikey的专栏
08-01 1652
import java.io.File; import java.util.ArrayList; /** * Created by mikeyna on 18-7-3. */ public class Files { /** * 搜索文件夹下指定扩展名 * @param Path 搜索目录 * @param Extension 扩展名 * ...
Android中字符串的拆分---split()方法
RELY_ON_YOURSELF的博客
08-02 9727
用法:String str = "wo-shi-test"; String [] temp = null; temp = str .split("-");但是要注意的是，如果使用”.”、”|”、”^”等字符做分隔符时，要写成s3.split(“\^”)的格式，否则不能拆分。
android 文件格式,Android java 获取文件格式
weixin_42477197的博客
05-26 257
有时候，我们需要对指定类型文件设定不同样式的icon，与文件扩展名一一对应，获取扩展名方法很笨，但是由于没有相关Api，也只能采用笨方法获取文件扩展名/*** 获取文件格式名*/public static String getFormatName(String fileName) {//去掉首尾的空格fileName = fileName.trim();String s[] = fileName....
android 开发--获取文件的扩展名和去掉文件的扩展名
yffhhffv的博客
11-17 650
android 开发--获取文件的扩展名和去掉文件的扩展名
Android开发之——FilenameFilter文件过滤器
ShanDong_Chu
10-11 4520
一、FilenameFilter介绍 java.io.FilenameFilter是文件名过滤器，用来过滤不符合规格的文件名，并返回合格的文件； 一般地： (1)String[] fs = f.list(); (2)File[] fs = f.listFiles(); 这两个方法返回f下的所有文件或目录； FilenameFilter用来把符合要求的文件或目录返回； 因此可以
python复制文件到另一个文件夹中如果重名则重命名
05-05
可以使用`shutil`模块中的`copy2()`函数来实现文件复制，并且如果目标文件夹中已经存在同名文件，则会自动重命名。 下面是一个简单的示例代码： ```python import os import shutil def copy_rename(src_file, dst_folder): # 获取文件名和扩展名 file_name, file_ext = os.path.splitext(os.path.basename(src_file)) # 目标文件路径 dst_file = os.path.join(dst_folder, os.path.basename(src_file)) # 如果目标文件已经存在，则重命名 if os.path.exists(dst_file): i = 1 while True: new_name = f"{file_name}_{i}{file_ext}" new_path = os.path.join(dst_folder, new_name) if not os.path.exists(new_path): dst_file = new_path break i += 1 # 复制文件 shutil.copy2(src_file, dst_file) return dst_file ``` 使用示例： ```python src_file = "/path/to/source/file.txt" dst_folder = "/path/to/destination/folder" dst_file = copy_rename(src_file, dst_folder) print(f"复制成功: {src_file} -> {dst_file}") ``` 在这个示例中，函数`copy_rename()`接受源文件路径和目标文件夹路径作为参数，并返回目标文件的路径。其中，`os.path.splitext()`函数可以将文件名和扩展名分离出来，`os.path.basename()`函数可以获取文件名（不包含路径）。 如果目标文件已经存在，则在文件名后面加上`_1`、`_2`、`_3`……，直到找到一个不存在的文件名为止。最后，使用`shutil.copy2()`函数复制文件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

锥栗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值