重构手法——函数行为重塑类 | 语意 | 替换算法

简介

"替换算法"是提升代码质量的战略性重构手法。通过用更清晰高效的算法替代现有实现，可以在保持功能不变的前提下显著改善代码的可维护性和执行效率。

针对的症状（代码坏味道）

• 现有算法难以理解或维护
• 存在更高效的标准库实现
• 算法性能无法满足需求
• 需要统一多个相似算法实现

替换算法的详细步骤

1. 理解原始算法
   • 确保完全掌握现有逻辑
   • 编写验证测试用例
2. 设计新算法
   • 选择更合适的算法策略
   • 保持输入输出格式不变
3. 逐步替换
   • 使用新算法逐步替代旧逻辑
   • 保持新旧算法并行运行
4. 验证结果
   • 确保功能一致性
   • 进行性能基准测试

示例

重构前代码：

String findMatch(List<String> list, String target) {
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i).equals(target)) {
            return list.get(i);
        }
    }
    return null;
}

重构后代码：

String findMatch(List<String> list, String target) {
    return list.stream()
            .filter(s -> s.equals(target))
            .findFirst()
            .orElse(null);
}

练习

基础练习题

1. 简单算法替换

   // 重构前
   int sum(int[] nums) {
       int total = 0;
       for (int n : nums) {
           total += n;
       }
       return total;
   }
   

进阶练习题

1. 复杂逻辑优化

   // 重构前
   boolean isPrime(int n) {
       if (n <= 1) return false;
       for (int i = 2; i * i <= n; i++) {
           if (n % i == 0) return false;
       }
       return true;
   }
   

综合拓展练习题

1. 性能关键算法

   // 重构前
   void sortUsers(List<User> users) {
       // 冒泡排序实现
       for (int i = 0; i < users.size() - 1; i++) {
           for (int j = 0; j < users.size() - i - 1; j++) {
               if (users.get(j).getId() > users.get(j + 1).getId()) {
                   User temp = users.get(j);
                   users.set(j, users.get(j + 1));
                   users.set(j + 1, temp);
               }
           }
       }
   }
   

代码审查要点

1. 优点：

   • 提升代码可读性
   • 优化性能表现
   • 利用语言特性

2. 潜在问题：

   • 保持功能完全等效
   • 注意边界条件处理
   • 评估算法复杂度