数字对比与替换系统的设计与实现：从需求分析到代码实践

个人名片

🎓作者简介：java领域优质创作者
🌐个人主页：码农阿豪
📞工作室：新空间代码工作室（提供各种软件服务)
💌个人邮箱：[2435024119@qq.com]
📱个人微信：15279484656
🌐个人导航网站：www.forff.top
💡座右铭：总有人要赢。为什么不能是我呢？

• 专栏导航：

码农阿豪系列专栏导航
面试专栏：收集了java相关高频面试题，面试实战总结🍻🎉🖥️
Spring5系列专栏：整理了Spring5重要知识点与实战演练，有案例可直接使用🚀🔧💻
Redis专栏：Redis从零到一学习分享，经验总结，案例实战💐📝💡
全栈系列专栏：海纳百川有容乃大，可能你想要的东西里面都有🤸🌱🚀

数字对比与替换系统的设计与实现：从需求分析到代码实践

1. 引言

在数据处理和算法设计中，经常需要比较两组数据的相似性。本文通过一个实际案例——多组数字对比与替换系统，详细介绍如何从需求分析到代码实现，完成一个功能完备的数字对比工具。我们将分别用 Java 和 Python 实现，并深入探讨对比逻辑的优化方式。

---

2. 需求分析

2.1 功能需求

1. 输入数据：
   • 多组A类数字（如A1, A2, A3, A4）
   • 一组B类数字（基准对比组）
2. 对比功能：
   • 主相同：数字相同且位置相同
   • 副相同：数字相同但位置不同（需排除主相同）
3. 替换功能：
   • 允许用户选择将B组数字替换到任意A组

2.2 示例输入与输出

输入：

A组:
A1: 340516154771  
A2: 348185279640  
A3: 548731001647  
A4: 348003001649  
B组: 045288193789

输出：

| 组号 | 主相同 | 副相同 |
| A1 | 3 | 2 |
| A2 | 2 | 3 |
| A3 | 0 | 2 |
| A4 | 4 | 0 |

替换操作：

输入替换组号（如2）: 4  
替换后的A4: 0 4 5 2 8 8 1 9 3 7 8 9

---

3. 核心算法设计

3.1 主相同（Exact Match）

• 定义：相同位置上的数字相同。
• 实现逻辑：

  int mainMatch = 0;
  for (int i = 0; i < length; i++) {
      if (a.charAt(i) == b.charAt(i)) {
          mainMatch++;
      }
  }
  

3.2 副相同（Partial Match）

• 定义：数字相同但位置不同（需排除主相同已匹配的数字）。
• 实现逻辑（Java）：

  int[] aCount = new int[10]; // 统计A中未匹配的数字频率
  int[] bCount = new int[10]; // 统计B中未匹配的数字频率
  
  for (int i = 0; i < length; i++) {
      if (a.charAt(i) != b.charAt(i)) {
          aCount[a.charAt(i) - '0']++;
          bCount[b.charAt(i) - '0']++;
      }
  }
  
  int subMatch = 0;
  for (int i = 0; i < 10; i++) {
      subMatch += Math.min(aCount[i], bCount[i]);
  }
  

3.3 替换功能

• 实现逻辑（Java）：

  public void replaceInA(int index) {
      if (index < 1 || index > groupA.length) {
          System.out.println("无效的组号");
          return;
      }
      groupA[index-1] = groupB;
      System.out.printf("替换后的A%d: %s\n", index, formatNumber(groupB));
  }
  

---

4. Java完整实现

import java.util.Scanner;

public class NumberComparator {
    private String[] groupA;
    private String groupB;
    
    public NumberComparator(String[] aNumbers, String bNumber) {
        this.groupA = aNumbers;
        this.groupB = bNumber;
    }
    
    // 对比所有A组与B组
    public void compareAll() {
        System.out.println("[对比结果]");
        System.out.println("| 组号 | 主相同 | 副相同 |");
        
        for (int i = 0; i < groupA.length; i++) {
            if (groupA[i] == null || groupA[i].isEmpty()) continue;
            
            int[] result = compareNumbers(groupA[i], groupB);
            System.out.printf("| A%d | %d | %d |\n", i+1, result[0], result[1]);
        }
    }
    
    // 对比两个数字字符串
    private int[] compareNumbers(String a, String b) {
        int mainMatch = 0;  // 主相同
        int subMatch = 0;    // 副相同
        
        int length = Math.min(a.length(), b.length());
        
        // 统计主相同
        for (int i = 0; i < length; i++) {
            if (a.charAt(i) == b.charAt(i)) {
                mainMatch++;
            }
        }
        
        // 统计副相同
        int[] aCount = new int[10];
        int[] bCount = new int[10];
        
        for (int i = 0; i < length; i++) {
            if (a.charAt(i) != b.charAt(i)) {
                aCount[a.charAt(i) - '0']++;
                bCount[b.charAt(i) - '0']++;
            }
        }
        
        for (int i = 0; i < 10; i++) {
            subMatch += Math.min(aCount[i], bCount[i]);
        }
        
        return new int[]{mainMatch, subMatch};
    }
    
    // 替换A组中的某个数字
    public void replaceInA(int index) {
        if (index < 1 || index > groupA.length) {
            System.out.println("无效的组号");
            return;
        }
        
        groupA[index-1] = groupB;
        System.out.printf("替换后的A%d: %s\n", index, formatNumber(groupB));
    }
    
    // 格式化数字输出
    private String formatNumber(String num) {
        return num.replace("", " ").trim();
    }
    
    public static void main(String[] args) {
        // 初始化数据
        String[] aNumbers = {
            "340516154771",
            "348185279640",
            "548731001647",
            "348003001649"
        };
        String bNumber = "045288193789";
        
        NumberComparator comparator = new NumberComparator(aNumbers, bNumber);
        
        // 显示初始数据
        System.out.println("A组数量: " + aNumbers.length);
        for (int i = 0; i < aNumbers.length; i++) {
            System.out.printf("A%d: %s\n", i+1, aNumbers[i]);
        }
        System.out.println("B组: " + bNumber);
        
        // 对比所有组
        comparator.compareAll();
        
        // 用户输入替换
        Scanner scanner = new Scanner(System.in);
        System.out.print("\n输入替换组号（如2）: ");
        int replaceIndex = scanner.nextInt();
        
        // 执行替换
        comparator.replaceInA(replaceIndex);
        
        scanner.close();
    }
}

---

5. Python实现对比

class NumberComparator:
    def __init__(self, a_numbers, b_number):
        self.group_a = a_numbers
        self.group_b = b_number
    
    def compare_all(self):
        print("[对比结果]")
        print("| 组号 | 主相同 | 副相同 |")
        
        for i, a_num in enumerate(self.group_a, 1):
            if not a_num:
                continue
            main_match, sub_match = self.compare_numbers(a_num, self.group_b)
            print(f"| A{i} | {main_match} | {sub_match} |")
    
    @staticmethod
    def compare_numbers(a, b):
        length = min(len(a), len(b))
        main_match = sum(1 for i in range(length) if a[i] == b[i])
        
        a_counts = [0] * 10
        b_counts = [0] * 10
        
        for i in range(length):
            if a[i] != b[i]:
                a_counts[int(a[i])] += 1
                b_counts[int(b[i])] += 1
        
        sub_match = sum(min(a_d, b_d) for a_d, b_d in zip(a_counts, b_counts))
        return main_match, sub_match
    
    def replace_in_a(self, index):
        if 1 <= index <= len(self.group_a):
            self.group_a[index-1] = self.group_b
            formatted = ' '.join(self.group_b)
            print(f"替换后的A{index}: {formatted}")
        else:
            print("无效的组号")

# 示例使用
if __name__ == "__main__":
    a_numbers = [
        "340516154771",
        "348185279640",
        "548731001647",
        "348003001649"
    ]
    b_number = "045288193789"
    
    comparator = NumberComparator(a_numbers, b_number)
    
    print(f"A组数量: {len(a_numbers)}")
    for i, num in enumerate(a_numbers, 1):
        print(f"A{i}: {num}")
    print(f"B组: {b_number}")
    
    comparator.compare_all()
    
    replace_index = int(input("\n输入替换组号（如2）: "))
    comparator.replace_in_a(replace_index)

---

6. 总结

1. 核心算法：
   • 主相同：直接逐位对比。
   • 副相同：统计未匹配数字的频率，取最小值求和。
2. Java vs Python：
   • Java更严谨，适合大型系统。
   • Python更简洁，适合快速开发。
3. 扩展方向：
   • 支持不同长度的数字对比。
   • 添加图形界面（如Swing或Tkinter）。

通过本文，读者可以掌握数字对比算法的设计与实现，并了解Java和Python在字符串处理上的差异。完整代码已提供，可直接运行测试！