Java中如何用冒泡排序对不同数组的关联数据按编号/姓名排序

一、原有冒泡排序代码的问题 #

• 核心逻辑错误：拆分关联数据独立排序，完全破坏了编号和姓名的绑定关系。你把编号存在num数组、姓名存在nem数组，排序时两个数组单独做交换操作：编号排序只调整num的元素顺序，姓名排序甚至直接按姓名字母序单独排列，最终输出时编号和姓名完全错位，和原始配对关系无关。
• 循环边界错误：数组总长度为7（索引范围0~6），但冒泡循环的终止条件写为j < 6，只会遍历到索引5的位置，最后一条索引为6的数据完全没参与排序，会出现数据遗漏。另外内层循环没有做轮次优化，虽然不影响结果，但会做很多无意义的比较。
• 逻辑冗余+比较方式不严谨：你专门把字符串编号转成int类型存入NUM数组，但后续排序逻辑完全没有用到这个数组，属于无效代码；另外直接用字符串compareTo比较数字内容，仅在当前等长带前导零的场景下结果和数值序一致，如果遇到长度不一致的数字字符串（比如"1234"和"999"），会出现字典序和数值序不符的排序错误。

二、按姓名字段排序关联数据的实现方法 #

完全支持按姓名字段排序，核心原则是不要拆分绑定的编号、姓名数据，排序交换位置时要把同一组关联数据作为整体移动，就不会出现错位问题。以下是两种可直接运行的实现方案：

方案1：修正冒泡逻辑，同步交换关联字段 #

不需要调整原始数组结构，排序时只要交换某一个字段的位置，同步交换对应索引的另一个字段即可，按编号排序、按姓名排序的逻辑通用：

public class SortTest {
    public static void main(String[] args) {
        String[] num = {"001", "980", "777", "169", "094", "233", "012"};
        String[] name = {"Graciella","Martinus","Renata","Vianney","Marcellin", "Joakim", "Steven"};
        int len = num.length;

        // 按编号升序排序
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                // 转成整数比较数值大小，避免字符串比较的坑
                int currentId = Integer.parseInt(num[j]);
                int nextId = Integer.parseInt(num[j+1]);
                if (currentId > nextId) {
                    // 交换编号
                    String tempNum = num[j];
                    num[j] = num[j+1];
                    num[j+1] = tempNum;
                    // 同步交换对应姓名，保证绑定关系
                    String tempName = name[j];
                    name[j] = name[j+1];
                    name[j+1] = tempName;
                }
            }
        }
        System.out.println("===按编号升序结果===");
        for (int i = 0; i < len; i++) {
            System.out.println(num[i] + "  " + name[i]);
        }

        // 重置原始数据，演示按姓名排序
        String[] num2 = {"001", "980", "777", "169", "094", "233", "012"};
        String[] name2 = {"Graciella","Martinus","Renata","Vianney","Marcellin", "Joakim", "Steven"};
        // 按姓名字母序升序排序
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (name2[j].compareTo(name2[j+1]) > 0) {
                    // 交换姓名
                    String tempName = name2[j];
                    name2[j] = name2[j+1];
                    name2[j+1] = tempName;
                    // 同步交换对应编号
                    String tempNum = num2[j];
                    num2[j] = num2[j+1];
                    num2[j+1] = tempNum;
                }
            }
        }
        System.out.println("\n===按姓名升序结果===");
        for (int i = 0; i < len; i++) {
            System.out.println(num2[i] + "  " + name2[i]);
        }
    }
}

方案2：实体类封装关联数据（工程化推荐写法） #

把编号和姓名封装成自定义类，排序时直接对实体对象数组做交换，不需要手动维护两个数组的同步关系，逻辑更清晰不容易出错：

// 自定义实体类封装关联字段
class User {
    private String id;
    private String name;

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() { return id; }
    public String getName() { return name; }
}

public class SortTest2 {
    public static void main(String[] args) {
        User[] users = {
                new User("001", "Graciella"),
                new User("980", "Martinus"),
                new User("777", "Renata"),
                new User("169", "Vianney"),
                new User("094", "Marcellin"),
                new User("233", "Joakim"),
                new User("012", "Steven")
        };
        int len = users.length;

        // 按编号升序排序
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                int currentId = Integer.parseInt(users[j].getId());
                int nextId = Integer.parseInt(users[j+1].getId());
                if (currentId > nextId) {
                    User temp = users[j];
                    users[j] = users[j+1];
                    users[j+1] = temp;
                }
            }
        }
        System.out.println("===按编号升序结果===");
        for (User u : users) {
            System.out.println(u.getId() + "  " + u.getName());
        }

        // 重置数据演示按姓名排序
        User[] users2 = {
                new User("001", "Graciella"),
                new User("980", "Martinus"),
                new User("777", "Renata"),
                new User("169", "Vianney"),
                new User("094", "Marcellin"),
                new User("233", "Joakim"),
                new User("012", "Steven")
        };
        // 按姓名升序排序
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (users2[j].getName().compareTo(users2[j+1].getName()) > 0) {
                    User temp = users2[j];
                    users2[j] = users2[j+1];
                    users2[j+1] = temp;
                }
            }
        }
        System.out.println("\n===按姓名升序结果===");
        for (User u : users2) {
            System.out.println(u.getId() + "  " + u.getName());
        }
    }
}

内容的提问来源于stack exchange，提问作者cerina