Java订单数组高效管理技巧

一分耕耘，一分收获！既然打开了这篇文章《Java高效管理订单数组：查改去重技巧》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

本文详细探讨了在Java中使用ArrayList管理订单数据时，如何避免重复订单ID并正确更新产品数量的常见问题。我们将深入分析直接使用ArrayList.contains()的局限性，并提供一种通过手动迭代、条件判断以及正确处理数组对象引用来高效检查、更新现有订单或添加新订单的解决方案。

Java ArrayList中订单管理的挑战

在处理订单系统时，一个常见的需求是存储一系列订单项，每个订单项包含一个产品ID和对应的数量。当用户添加新订单时，如果该产品ID已存在于订单列表中，我们不应重复添加该产品，而应更新其数量。如果产品ID是新的，则将其作为一个新的订单项添加。

假设我们使用ArrayList来存储订单，其中每个int[]代表一个订单项，int[0]存储产品ID，int[1]存储产品数量。初学者常遇到的问题是如何有效地检查ArrayList中是否已存在某个产品ID，并在存在时更新其数量，而不是错误地添加新的重复项。

初始尝试与常见误区

许多开发者在初次尝试解决此问题时，可能会倾向于使用ArrayList自带的contains方法，并结合简单的逻辑判断，例如：

// 假设 Order[0] = idConso; Order[1] = nbrConso;
if (ord.contains(Order[0] == idConso) && Order[0] == idConso) {
    System.out.println("containe ");
    Order[1] += nbrConso; 
}
ord.add(Order); // 无论是否找到，都添加

这种方法存在几个关键问题：

1. ord.contains(Order[0] == idConso)的误解： Order[0] == idConso是一个布尔表达式，其结果为true或false。ArrayList.contains()方法期望传入一个与列表中元素类型相匹配的对象。对于ArrayList，contains方法会检查列表中是否存在一个与传入参数“相等”的int[]对象。将一个布尔值传入contains方法，它永远不会找到一个int[]对象，因此ord.contains(true)或ord.contains(false)总是返回false。
2. int[]的相等性： 即使我们能够正确地传入一个int[]对象，ArrayList.contains()在比较int[]对象时，默认使用的是对象引用相等性（即两个引用是否指向内存中的同一个对象），而不是内容相等性（即两个数组的元素是否相同）。因此，即使两个int[]数组内容完全一样，如果它们是不同的对象，contains也会返回false。
3. 无条件添加： 在上述逻辑中，即使“找到了”匹配项（虽然实际上并未找到），代码仍然会执行ord.add(Order)，导致重复添加。

正确的解决方案：迭代与条件更新

要正确实现检查和更新逻辑，我们需要手动遍历ArrayList中的每个int[]元素，检查其产品ID（int[0]），如果找到匹配项，则更新其数量（int[1]）并标记已找到，然后跳出循环。如果遍历结束后仍未找到匹配项，则添加新的订单项。

以下是修正后的逻辑：

// 在获取 idConso 和 nbrConso 后
int[] currentOrder = new int[2]; // 为当前订单创建一个新的数组对象
currentOrder[0] = idConso;
currentOrder[1] = nbrConso;

boolean foundExistingOrder = false;
for (int[] existingOrder : ord) { // 遍历 ArrayList 中的每个现有订单
    if (existingOrder[0] == idConso) { // 检查产品ID是否匹配
        System.out.println("检测到现有订单，更新数量。");
        existingOrder[1] += nbrConso; // 更新现有订单的数量
        foundExistingOrder = true; // 标记为已找到
        break; // 找到后即可停止遍历
    }
}

if (!foundExistingOrder) { // 如果没有找到匹配的订单ID
    ord.add(currentOrder); // 将新的订单项添加到列表中
    System.out.println("添加新订单项。");
}

关键点说明：

• 手动迭代： 我们使用增强型for循环遍历ord中的每个int[]元素。
• 直接比较ID： existingOrder[0] == idConso直接比较了现有订单的产品ID与当前输入的产品ID。
• 更新现有对象： 如果找到匹配项，我们直接修改existingOrder[1]，这会影响ArrayList中存储的那个int[]对象，因为existingOrder是该对象的引用。
• foundExistingOrder标志： 这个布尔变量用于控制是否需要添加新的订单项。
• break语句： 一旦找到并更新了匹配项，就没有必要继续遍历列表，break可以提高效率。

处理对象引用：避免意外修改

除了上述逻辑问题，还有一个常见的陷阱是关于Java中对象引用的行为。如果将int[] Order = new int[2];声明在循环外部，那么每次用户输入订单时，你都会修改同一个Order数组对象，并多次将其引用添加到ArrayList中。最终，ArrayList中的所有元素都将指向同一个int[]对象，并且它们的值将是最后一次修改Order数组时的值。

为了确保每个订单项都是一个独立的int[]对象，必须在每次处理新订单时创建新的int[]实例。

错误示例（Order在循环外声明）：

// ...
int [] Order = new int [2]; // 声明在循环外

do {
    // ... 获取 idConso 和 nbrConso
    Order [ 0 ] = idConso ;
    Order [ 1 ] = nbrConso ;

    // ... 上述的检查和添加逻辑
    // 如果这里直接 ord.add(Order);
    // 那么每次添加的都是同一个 Order 对象的引用
} while (...);

正确做法（Order在循环内声明）：

public static void getOrder ( ArrayList<int[]> ord ) {
    // ... 其他变量声明
    String UserInput;
    int idConso = 0, nbrConso = 0;

    UserInput = getUserIntOrSpecificInputV2("Entrez le N° de consommable ...", "Q", 1, NAMES.length);

    do {    
        // ... 处理用户输入 idConso 和 nbrConso

        // 每次循环都创建一个新的 int[] 数组
        int [] currentOrder = new int [2]; 
        currentOrder [ 0 ] = idConso ;
        currentOrder [ 1 ] = nbrConso ;

        boolean foundExistingOrder = false;
        for (int[] existingOrder : ord) {
            if (existingOrder[0] == idConso) {
                System.out.println("检测到现有订单，更新数量。");
                existingOrder[1] += nbrConso;
                foundExistingOrder = true;
                break;
            }
        }

        if (!foundExistingOrder) {
            ord.add(currentOrder); // 添加新的订单项
            System.out.println("添加新订单项。");
        }

        UserInput = getUserIntOrSpecificInputV2("Entrez le N° de consommable ou Q(Quitter) V (Valider le ticket) ", "QV",1, NAMES.length);

    } while (!UserInput.equalsIgnoreCase("V"));

    // ... 打印订单列表
}

完整的getOrder方法示例

结合上述所有修正，一个健壮的getOrder方法应如下所示：

package testes;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class test_EX_24V1 {

    final static String NAMES[] = 
        {
                "Spa reine 25 ","Bru plate 50","Bru pét 50","Pepsi","Spa orange",
                "Schweppes Tonic","Schweppes Agr","Ice Tea","Ice Tea Pêche","Jus d'orange Looza", "Cécémel", 
                "Red Bull","Petit Expresso","Grand Expresso","Café décaféiné ","Lait Russe ","Thé et infusions",
                "Irish Coffee ","French Coffee ","Cappuccino","Cécémel chaud","Passione Italiano","Amour Intense",
                "Rhumba Caliente ","Irish Kisses ","Cuvée Trolls 25","Cuvee Trolls 50","Ambrasse-Temps 25","Ambrasse-Temps 50 ",
                "Brasse-Temps Cerises 25","Brasse-Temps Cerises 50","La Blanche Ste Waudru 25","Blanche Ste Waudru 50",
                "Brasse-Temps citr 25","Brasse-Temps citr 50","Spaghetti Bolo ","Tagl Carbonara","Penne poulet baslc ",
                "Tagl American","Tagl saum"
        };

    public static String getUserIntOrSpecificInputV2(String msg, String expectedAnsw, int min, int max) {
        int intInput = 0;
        String strAnsw = "";
        Scanner sc= new Scanner (System.in);
        do {
            System.out.println(msg);
            if (sc.hasNextInt()) {
                intInput = sc.nextInt();
                if (intInput >= min && intInput <= max) {
                    return Integer.toString(intInput);
                } else {
                    System.out.println("La saisie doit être comprise entre " + min +  " et " + max);
                }
            } else {
                strAnsw = sc.next();
                if (strAnsw.length() == 1 && expectedAnsw.toUpperCase().contains(strAnsw.toUpperCase())){
                    return strAnsw.toUpperCase();
                } else {
                    System.out.println ("Erreur de saisie : caractères autorisés " +  expectedAnsw );
                }
            }
        } while (true);
    }

    public static void getOrder ( ArrayList<int[]> ord ) {
        String UserInput;
        int idConso = 0, nbrConso = 0;

        do {    
            UserInput = getUserIntOrSpecificInputV2("Entrez le N° de consommable "
                    + "ou Q(Quitter) ", "Q", 1, NAMES.length);

            if ( UserInput.equalsIgnoreCase( "Q" ) ) {
                System.out.println( "Fin de Programme, Au Revoir" );
                System.exit( -1 );
            } else {
                idConso = Integer.parseInt ( UserInput );
            }

            UserInput = getUserIntOrSpecificInputV2("Nombre de consommations pour " + NAMES [ idConso -1 ] +" ? /A(Annuler) /Q (Quitter)", "AQ", 1, 5000);

            if ( UserInput.equalsIgnoreCase("Q") ) {
                System.out.println( "Fin de Programme, Au Revoir" );
                System.exit(-1);            
            } else if ( UserInput.equalsIgnoreCase("A") ) { 
                // 用户选择取消，重新开始获取商品ID
                continue; // 跳过当前循环的剩余部分，进入下一次循环
            }
            nbrConso = Integer.parseInt ( UserInput );

            // 每次处理新订单时，创建新的 int[] 实例
            int [] currentOrder = new int [2]; 
            currentOrder [ 0 ] = idConso ;
            currentOrder [ 1 ] = nbrConso ;

            boolean foundExistingOrder = false;
            for (int[] existingOrder : ord) {
                if (existingOrder[0] == idConso) {
                    System.out.println("检测到现有订单 (" + NAMES[idConso - 1] + ")，更新数量。");
                    existingOrder[1] += nbrConso;
                    foundExistingOrder = true;
                    break;
                }
            }

            if (!foundExistingOrder) {
                ord.add(currentOrder);
                System.out.println("添加新订单项 (" + NAMES[idConso - 1] + ")。");
            }

            UserInput = getUserIntOrSpecificInputV2("Entrez le N° de consommable 或 Q(Quitter) V(Valider le ticket) ", "QV",1, NAMES.length);

        } while (!UserInput.equalsIgnoreCase("V"));

        System.out.println("\n--- 最终订单列表 ---");
        for ( int[] item : ord ) {
            System.out.println("产品ID: " + item[0] + " (" + NAMES[item[0] - 1] + "), 数量: " + item[1]);
        }
        System.out.println("订单项总数: " + ord.size());
    }

    public static void main(String[] args) {
        ArrayList <int [] > orderList = new ArrayList<int[]>();
        getOrder(orderList);
    }
}

注意事项：

• 在getUserIntOrSpecificInputV2方法中，Scanner对象在循环内部创建，这可能导致资源泄露或行为异常。通常，Scanner应在方法外部创建并传入，或在方法开始时创建并在方法结束时关闭。为简化示例，这里未作修改。
• NAMES数组的索引是从0开始，而idConso通常从1开始，因此在访问NAMES时需要使用idConso - 1。
• continue语句在用户选择“A”(Annuler)时非常有用，它会跳过当前循环的剩余部分，直接进入下一次循环，让用户重新输入商品ID。

总结与进阶思考

通过本文，我们学习了在Java ArrayList中管理订单数据时，如何正确地检查、更新和添加订单项。核心要点包括：

1. 避免ArrayList.contains()的误用： 对于自定义对象（包括数组），contains()默认进行引用比较，不适用于内容比较。
2. 手动迭代是关键： 必须手动遍历列表，逐个检查元素的特定属性（如产品ID）。
3. 正确处理对象引用： 确保每次添加新订单项时都创建一个新的int[]实例，以避免所有列表元素都指向同一个对象。

对于更复杂的场景，使用自定义类（例如OrderLine类，包含productId和quantity字段）并重写其equals()和hashCode()方法，然后将其存储在ArrayList中，会使代码更加清晰和易于维护。此外，如果查询和更新操作非常频繁，可以考虑使用HashMap（将产品ID映射到数量）作为数据结构，以实现O(1)的平均时间复杂度。

到这里，我们也就讲完了《Java订单数组高效管理技巧》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！