Java数组-不确定方法

我被安排了一个Java作业，它基本上是一个餐厅的模型。除了最困难的部分外，我基本上已经完成了。它基本上是处理数组和对象；有几个部分我不确定。我已经完成了实现ArrayList和使用Map/HashMap实现另一个ArrayList的类

这就是我到目前为止所做的：

package restaurant;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;


public class ArrayOrder implements Order {

    Product order[];

    public ArrayOrder() {
        this.order = new Product[1000];
    }

    public Iterator<Product> iterator() {

    }


    public void addItem(Product product, int quantity) {    
        /*for(int i = 0; i < quantity; i++)
        {
            this.order[i] = product; // WRONG CODE
        }*/
    }


    public void removeItem(Product product) {

    }


    public int numberOfItems() {
        int length = 0;
        for(int i = 0; i < this.order.length; i++){
            if(this.order[i] != null) {
                length++;
            }
        }
        return length;
    }


    public int totalCost() {
        int resultcost = 0;
        for(int i = 0; i < this.order.length; i++) {
            if(this.order[i] != null) {
                    resultcost += this.order[i].getCost();
            }
        }
        return resultcost;
    }

    public String toString() {
            return Arrays.toString(this.order);
    }

    public int hashCode() {

    }

    public boolean equals() {

    }
}

toString

方法产生：

[Salad - A traditional English salad (serves 1) $7.50, Salad - A traditional English salad (serves 1) $7.50, null, null, null, null, null, null, null, null]

我希望它在null，null，null之前停止。。但它接受整个数组，其中8个为空值；我不确定如何解决这个问题。数组周围是否还有其他内容并定义其长度；在上面的示例中，我只添加了2项，但声明了一个长度为[10]的数组；我如何知道定义数组的长度？如果用户在我上面的示例中添加了20个启动器，程序将崩溃

当我用main方法测试numberOfItems和totalCost函数时，它们就工作了

如果您能给我指点正确的方向，我将不胜感激。 谢谢

编辑： 我想我有点不清楚；要求是，我要基于UML图创建几个类。此时，我必须创建3个类，所有这些类都实现了Order接口。这三个类是（ListOrder、ArrayOrder、MapOrder）。我已经完成了MapOrder和ListOrder，但是我被困在ArrayOrder上了

这是我的ArrayList类：

package restaurant;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListOrder implements Order{

    private List<Product> order;

    public ListOrder() {
        this.order = new ArrayList<Product>();
    }

    public Iterator<Product> iterator() {
        return order.iterator();
    }


    public void addItem(Product product, int quantity) {
        for(int i = 0; i < quantity; i++) {
            this.order.add(product);
        }
    }


    public void removeItem(Product product) {
        this.order.remove(product);
    }


    public int numberOfItems() {
        return this.order.size();
    }


    public int totalCost() {
        int resultcost = 0;
        for(Product p : order)
        {
            resultcost += p.getCost();
        }
        return resultcost;
    }

    public String toString() {
        return this.order.toString();
    }

}

套餐餐厅；
导入java.util.ArrayList；
导入java.util.Iterator；
导入java.util.List；
公共类ListOrder实现了Order{
私有列表顺序；
公共秩序{
this.order=new ArrayList（）；
}
公共迭代器迭代器（）{
return order.iterator（）；
}
公共无效附加项（产品、整数数量）{
对于（int i=0；i

Java中的数组大小是固定的：实例化时，必须提供大小。在实例化之后，数组的大小永远不会改变

您需要的是定义动态大小数组的工具。为此，标准JDK中存在许多工具。查看

列表

界面及其各种实现（

ArrayList

，

LinkedList

等等）。

一些要点：

• 您正在导入

  数组列表

  ，

  数组

  ，

  迭代器

  ，但从未使用它们，目的是什么？您只是在使用一个静态数组，它有您提到的问题
<> LI>你应该考虑使用<代码> ARAYLISTAB/CODE来内部存储你的元素，为什么你会麻烦管理一个静态数组，如果有一个类为你包好这个功能，那么如果需要的话，它必须增长？（实际上，

LinkedList

更适合您的情况，请看下一点）
• 通过查看您应该向外部提供的内容，我发现您不需要随机访问，这意味着，如果您真的想要滚动自己的集合，您应该将其建模为一个链接列表，因为您不会遇到您提到的问题（例如必须增加数组的大小或管理空值）

---

据我所知，您已经使用

ArrayList

和

Map

实现了相同的功能，现在需要使用数组来实现

最简单的方法是保留一个包含有效元素数的额外字段。不要依赖于查找

null

元素，因为这样做效率低且容易出错（特别是当需求突然发生变化时，您需要考虑

null

元素）

您还需要一个

int quantities[]

字段来维护数量。这两个数组的大小应始终相同

然后，当您必须添加新元素时，可以将有效元素的数量与

order.length

（当前分配的“容量”）进行比较。如果添加新元素将超过容量，则只需重新分配

订单

：

public void addItem(Product product, int quantity) {    
    if (currentSize >= order.length) {
        Product[] temp = new Product[order.length + GROWTH_FACTOR];
        System.arraycopy(order, 0, temp, 0, currentSize);
        order = temp;
        int[] q2 = new int[order.length + GROWTH_FACTOR];
        System.arraycopy(quantities, 0, q2, 0, currentSize);
        quantities = q2;
    }
    quantities[currentSize] = quantity;
    order[currentSize++] = product;
}

这里的

GROWTH\u FACTOR

是一个常数，表示当空间不足时阵列的扩展量

或者，您可以引入一个私有静态类，该类保留产品/数量对：

private static class OrderItem {
    final Product product;
    final int quantity;
    OrderItem(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }
}

private OrderItem[] orders;
private int currentSize;

public void addItem(Product product, int quantity) {
    if (currentSize >= orders.length) {
        // reallocate orders array
    }
    orders[currentSize++] = new OrderItem(product, quantity);
}

---

我不明白为什么不能在内部使用

ArrayList

。这是明令禁止的吗？您正在尝试使用静态数组对动态数组进行建模，而这正是

ArrayList

所做的。An是一个“动态数组”，它为您提供了一个自动重新调整大小的“数组”，其中还包括内置的添加/插入和删除方法。我根本看不到您使用ArrayList。使用ArrayList是在不知道集合大小的情况下创建集合的一种方法。对于

toString（）

问题，您需要独立于数组大小跟踪项目的数量。整型字段计数器可以很好地完成这一任务。再仔细看看您的

numberOfItems（）

实现……“不可变”的意思相当具体——可能需要使用不同的词。（例如不可更改）嗨，我一直在搞乱代码，忘了删除我导入的一些东西。我计划在add&remove函数运行之后编写迭代器函数。谢谢你的帮助，我对第一段代码有点不确定；currentSize变量是什么？如何实现/确定增长系数？感谢您的帮助，@user1874133-

currentSize

应该是y字段

private static class OrderItem {
    final Product product;
    final int quantity;
    OrderItem(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }
}

private OrderItem[] orders;
private int currentSize;

public void addItem(Product product, int quantity) {
    if (currentSize >= orders.length) {
        // reallocate orders array
    }
    orders[currentSize++] = new OrderItem(product, quantity);
}