检查列表中的元素是否有效并且按正确的顺序为

Question

我正在制作一家地铁餐厅的复制品，您将在其中收到一定序列的订单，并检查序列是否有效，以及成分是否在菜单中。

正确的顺序是：1面包，0至1肉，1奶酪，1至3个额外的额外，1至3个调味料。

这意味着订单至少可以具有4种成分（面包，奶酪，另外1个调味料）和最多9种成分（面包，肉，奶酪，3种额外的额外，3个调味料）。

我的问题是，是否有更优化/更智能的方法可以验证比我的每种成分？

代码：

// Example order
HashMap<String, HashSet<String>> menu = new HashMap<>();

public static void main(String[] args) {
    // Example order
    List<String> ingredients = Arrays.asList("Wheat", "Veal",
        "Yellow", "Cucumbers", "Onions");
    if (!isValid(ingredients)) {
        // throw exc;
}
    
    
    
boolean isValid(List<String> ingredients) {
    if (ingredients.size() < 4 || ingredients.size() > 9) {
        return false;
    }
    int i = 0;
    // Bread
    if (!Restaurant.menu.get("Bread")
            .contains(ingredients.get(i++))) {
        System.out.println("Bread");
        return false;
    }
    
    // Meat
    if (!(Restaurant.menu.get("Meat")
            .contains(ingredients.get(i)))
            && !Restaurant.menu.get("Cheese")
                    .contains(ingredients.get(i))) {
        System.out.println("Meat");
        return false;
    }
    
    if (Restaurant.menu.get("Meat")
            .contains(ingredients.get(i))) { // Meat case
        if ((!Restaurant.menu.get("Cheese")
                .contains(ingredients.get(++i)))) {
            System.out.println("Cheese");
            return false;
        }
    }
    
    for (int j = ++i; j < ingredients.size(); j++) {
        if ((!Restaurant.menu.get("Extras")
                .contains(ingredients.get(j)))) { // Extras
            if (j == i) {
                return false;
            } else {
                if ((!Restaurant.menu.get("Sauces")
                        .contains(ingredients.get(j)))) { // Sauces
                    return false;
                }
            }
        }
    }
    
    return true;
}

注意1：我知道规则“如果起作用，请不要触摸它“但是我觉得这个代码正在进入意大利面代码的领域，其中一堆IF基本上是在大量情况下检查类似的东西，而如果有一种更优化的方式，我现在想不到第二个意见。

注2：我选择菜单上的arraylist上的标签，因为搜索速度更快。

Answer 1

首先，您的一般方法没有真正的错。

话虽如此，有一些错误。

• 您将hashmap视为通过餐厅的静态价值，该餐厅并未宣布为静态。
• 您正在从静态上下文（main）中调用 iSvalid（），但该方法并未声明为静态。

这就是我可以处理的方式。这并不是说这是最好的方法或样式。

• 我选择使用 enum 保留有关每个菜单项的详细信息，以及一个处理订单的类。 Enum很容易地满足这种要求。我建议您阅读它们（他们参与其中，无法在此处详细解释）。但是，由于它们是静态，最好在不可能更改的值中使用。

• 每个项目都有两个参数在 enum的构造函数中进行处理。

• 因此，每个项目都有其项目的单独范围（成分）

• enum 还具有验证方法，可以检查提供的项目计数是否满足要求。

实际订单在 myorder 类中。

• 它包含一个地图，以保留每种成分的计数。
• 给定成分的添加方法将当前数量添加到地图中。
• 以及一种显示有关该订单的信息信息的显示方法。

enum Menu {MEAT(0,1), BREAD(1,1), CHEESE(1,1), EXTRAS(1,3), SAUCES(1,3);
    private int min;
    private int max;
    private Menu(int min, int max) {
        this.min = min;
        this.max = max;
    }
    
    public int getMax() {
        return max;
    }
    public int getMin() {
        return min;
    }
    
    public  boolean validate(int count) {
        return count >= min && count <= max;
    }
}
class MyOrder {
    private EnumMap<Menu, Integer> counts = new EnumMap<>(Menu.class);
    
    public void display() {
        for (Menu item : Menu.values()) {
            int count = counts.get(item);
        System.out.printf("%-7s: %d  (%d,%d) %s%n",item.name(), count, item.getMin(), item.getMax(),
                item.validate(count) ? "" : "Item count out of range.");
        }
    }
        
    public boolean add(Menu item, int quantity) {
        return item.validate(counts.merge(item, quantity, Integer::sum));
    }
}
        
public class Restaurant {

    public static void main(String[] args) {
        boolean isValid;
        MyOrder order = new MyOrder();
        isValid =  order.add(Menu.BREAD,2);
        isValid &= order.add(Menu.MEAT,1);
        isValid &= order.add(Menu.CHEESE,2);
        isValid &= order.add(Menu.EXTRAS,3);
        isValid &= order.add(Menu.SAUCES,2);
        if (isValid) {
            System.out.println("Your order is accepted.");
        } else {
            System.out.println("Order is not in compliance");
            order.display();
        }
    }
}

打印

Order is not in compliance
MEAT   : 1  (0,1) 
BREAD  : 1  (1,1) 
CHEESE : 2  (1,1) Item count out of range.
EXTRAS : 3  (1,3) 
SAUCES : 2  (1,3) 

还请记住，如果语句是 boolean ，则任何的结果。因此，不等式可以分配给布尔值，然后进行稍后测试（如果这样做是有意义的）。另请注意，直到最后我才检查合法订单。有些人可能宁愿在发生不良订单时发出信号。这是一个设计选择。

有关更多信息检查。
enum

Map.merge

Answer 2

我在您提出的解决方案中看到的问题是，它试图一次解决所有问题，而不是单独解决它们。在我看来，这使您的代码难以阅读和理解。虽然可以正常工作，但您添加的业务规则就越多，它就会越难。

那你该怎么办？分开关注点。

第一个问题是要加入一种成分：是面包，奶酪，肉，额外的酱汁吗？您可以使用方法 getCategory（）来创建类菜单（而不是仅使用返回类别的 HashSet ），并且回报值可能是枚举。

SEOND担忧是秩序。您可以使用自定义<代码>比较器检查列表的顺序。请参阅此问题有关详细信息。

第三个问题是特定类别的成分数量。鉴于您可以找出成分的类别，因此您可以计算有多少含量，并检查是否合适。

关于如何实现这一目标还有更多的话要说，我只想将您指向可能的方向。