java中一种产品的库存仅减少？答案

【问题标题】：Inventory only decreasing for one product in java?java中一种产品的库存仅减少？
【发布时间】：2016-03-11 17:45:22
【问题描述】：

我试图在销售商品后使用二维数组作为销售数据来计算库存，但只计算我的第二个产品 ID 的库存？我使用一个二维数组作为库存，使用第二个二维数组作为按顺序读取的销售数据。第一个数组在第一列中包含产品 ID，在第二列中包含起始库存。

打印的库存数组：

10001       |  3
10002       |  33
10003       |  51
10004       |  101
10005       |  4
10006       |  30
10007       |  36
10008       |  8
10009       |  22
10010       |  74
20001       |  24
20002       |  13
20003       |  0
20004       |  62
20005       |  21
20006       |  22
30001       |  59
30002       |  7
30003       |  18
30004       |  44
30005       |  28
30006       |  106
30007       |  23
30008       |  8
30009       |  29
30010       |  7
30011       |  20
30012       |  24
30013       |  55
30014       |  15
30015       |  64
30016       |  15
30017       |  13
30018       |  34
30019       |  44
30020       |  39

打印的销售数据数组：

10002       ||  4
10004       ||  6
10008       ||  2
10010       ||  3
10010       ||  3
10007       ||  10
20003       ||  4
20003       ||  7
30019       ||  1
30020       ||  9
10004       ||  9
10006       ||  7
20005       ||  5
30004       ||  10
20004       ||  2
30002       ||  7
30013       ||  6
20005       ||  5
30006       ||  1
30006       ||  7
30007       ||  2
30012       ||  10
30015       ||  7
30015       ||  3
10001       ||  5
20001       ||  8
30007       ||  3
30014       ||  3
30015       ||  6
30016       ||  2
10001       ||  8
10003       ||  8
10007       ||  5
10007       ||  8
20005       ||  6
20006       ||  10
30003       ||  4
30011       ||  7
30014       ||  7
30016       ||  5
20003       ||  1
30003       ||  4
30010       ||  5
30011       ||  8
30012       ||  1
30014       ||  9
30016       ||  4
30018       ||  5
10006       ||  1
10010       ||  9
20005       ||  5
30001       ||  1
30004       ||  9
30007       ||  5
30009       ||  1
30014       ||  6
30016       ||  5
30016       ||  2
30020       ||  8
10004       ||  3
10004       ||  7
10008       ||  2
20001       ||  4
20003       ||  7
20004       ||  6
20006       ||  2
30001       ||  1
30003       ||  7
30004       ||  1
30004       ||  10
30005       ||  2
30006       ||  7
30017       ||  10
30018       ||  2
30004       ||  6
10009       ||  9
10009       ||  7
10010       ||  10
20005       ||  3
30002       ||  1
30004       ||  2
30004       ||  8
30013       ||  3
30019       ||  3
10004       ||  10
10007       ||  5
30001       ||  7
30003       ||  6
30006       ||  2
30006       ||  3
30007       ||  2
30013       ||  8
30016       ||  8
10003       ||  6
10004       ||  9
10004       ||  2
10006       ||  8
10010       ||  1
20003       ||  9
20003       ||  10
30001       ||  8
30002       ||  1
30013       ||  5
30015       ||  7
30018       ||  1
30019       ||  10
30020       ||  9
10008       ||  1
10009       ||  3
20004       ||  10
30010       ||  7
30012       ||  9
30014       ||  7
30017       ||  4
20004       ||  5
30005       ||  8
30010       ||  7
30011       ||  1
10004       ||  9
10004       ||  4
10006       ||  5
10010       ||  7
20001       ||  3
20003       ||  2
20004       ||  7
30004       ||  8
30010       ||  2
30012       ||  5
30019       ||  8
30020       ||  1
10008       ||  7
30001       ||  9
30003       ||  10
30003       ||  8
30006       ||  5
30008       ||  10
30009       ||  7
30009       ||  8
30015       ||  9
30017       ||  9
30018       ||  7
30020       ||  1
10001       ||  7
10002       ||  10
10003       ||  3
10005       ||  4
10010       ||  4
20001       ||  4
20002       ||  1
20005       ||  5
30006       ||  9
30006       ||  6
10003       ||  7
10003       ||  4
10004       ||  6
10009       ||  6
20002       ||  6
20004       ||  3
20005       ||  3
30001       ||  9
30005       ||  2
30006       ||  10
30008       ||  6
30009       ||  6
30011       ||  10
30013       ||  8
30013       ||  3
30013       ||  5
30015       ||  1
30019       ||  10
10002       ||  6
10004       ||  7
10006       ||  3
10006       ||  2
20002       ||  6
20004       ||  7
20004       ||  7
30005       ||  4
30006       ||  8
30007       ||  3
30008       ||  6
30009       ||  8
30014       ||  5
30015       ||  10
30015       ||  9
30018       ||  3
30019       ||  2
30019       ||  9
30020       ||  1
10006       ||  10
20003       ||  2
30001       ||  3
30005       ||  5
30012       ||  5
30015       ||  5
30015       ||  3
30016       ||  2
30019       ||  8
30019       ||  5

我尝试按顺序读取销售数据数组和库存数组，并在库存充足的情况下从库存中减去单位，但我的输出显示仅计算第二个产品 ID 的库存？我不知道为什么它只适用于第二个产品 ID，所以任何帮助都将不胜感激。

         int i = 0;//counter for rows in sales data
         int k = 0;//counter for rows in inventory
         while(i < sale.length ){//while not end of sale data array
             if(inv [k][0] == sale[i][0]{//if the product ids are the same
                 if(inv[k][1] < sale[i][1]){//if the inventory is less than the units to be sold
                     i = 0;//go back to beginning of sale data
                     if(k < inv.length){ //while not end of inventory array
                       k++;//move to next inventory item 
                    }
                 }       
                 if((inv[k][1] > sale[i][1]) && (inv[k][1] > 0)){//if there is enough inventory
                     inv[k][1] = inv[k][1] - sale[i][1];//subtract units from inventory
                     i++;//move to next sales item
                 }
             }
             else{
                 i++;//move to next sales item
             }
        }

我的输出：

10001       |  3
10002       |  13
10003       |  51
10004       |  101
10005       |  4
10006       |  30
10007       |  36
10008       |  8
10009       |  22
10010       |  74
20001       |  24
20002       |  13
20003       |  0
20004       |  62
20005       |  21
20006       |  22
30001       |  59
30002       |  7
30003       |  18
30004       |  44
30005       |  28
30006       |  106
30007       |  23
30008       |  8
30009       |  29
30010       |  7
30011       |  20
30012       |  24
30013       |  55
30014       |  15
30015       |  64
30016       |  15
30017       |  13
30018       |  34
30019       |  44
30020       |  39

【问题讨论】：

标签： java arrays inventory

【解决方案1】：

你的逻辑有问题。

您移动到不同库存项目的唯一时间是当您没有足够的库存时。

但是，当您完成特定产品的所有销售项目时，其中可能仍有一些库存。如果您售出的产品少于库存，那么您将永远不会达到库存不足的地步。因此，您将永远无法获得下一个产品。

在您的特定情况下，商品 10001 的首次销售比您拥有的多。所以它移动到项目 10002。但是项目 10002 有 33 个，但你只卖了 20 个。你在没有得到inv[k][1] < sale[i][1]的情况下完成了循环。

我相信你的逻辑应该不同。假设你不能使用集合和映射（这将更适合这个），只有这样的数组，那么你应该：

逐一检查库存数组。
对于每个库存商品，在销售数组中搜索该商品的所有销售额，并根据需要从库存中减去，直到库存用完。

所以你会在一个循环内有一个循环。

【讨论】：

【解决方案2】：

首先，对于这个问题，您可能希望使用HashMap<Integer,Integer> 而不是数组。

现在，对于您的问题：您的循环逻辑存在问题。 @RealSkeptic 指出了他的回答中的缺陷。如果您从按 productId 对销售数据进行排序开始，您的解决方案可以大大简化。您可以使用Comparator（改编自this answer）对二维数组进行排序：

    Arrays.sort(sale, new Comparator<Integer[]>() {
        @Override
        public int compare(final Integer[] entry1, final Integer[] entry2) {
            final Integer v1 = entry1[0];
            final Integer v2 = entry2[0];
            return v1.compareTo(v2);
        }
    });

应该使用相同的方法来确保您的inv 数组也被排序。排序后，您可以使用以下（简化的）循环处理销售：

    int i = 0; //inventory id
    for(int k=0; k < sale.length; k++){
        if(inv[k][0] == sale[i][0]){ //if product Ids match
            if(inv[k][1] >= sale[i][1]){ //if there's enough inventory
                inv[k][1] -= sale[i][1]; //subtract units from inventory
            }
        } else { //no more sales for this productId
            i++; //move to next item in the inventory
        }
    }

编辑：根据您在下面的评论，您可以按照@RealSkeptic 的建议进行操作并使用嵌套循环。但是，我强烈建议您改用HashMap。例如：

final HashMap<Integer,Integer> inv = initInventory();
final int[][] sale = initSalesData();

//process the sales data
for(int i = 0; i < sale.length; i++){ //for each sale
    final int saleProductId = sale[i][0]; //get the sale productId 
    final int saleQty = sale[i][1]; // get the sale quantity
    final Integer qty = inv.get(saleProductId); //get the inventory quantity
    if(qty != null && qty >= saleQty){ //if productId is valid and inventory has sufficient quantity
        inv.put(saleProductId, qty-saleQty); //update inventory quantity
    }
}

您可以使用以下代码测试此方法。输入基于您提供的输入：

import java.util.HashMap;

public class InventoryExample {

    public static void main(String[] args) {

        final HashMap<Integer,Integer> inv = initInventory();
        final int[][] sale = initSalesData();

        //process the sales data
        for(int i = 0; i < sale.length; i++){ //for each sale
            final int saleProductId = sale[i][0]; //get the sale productId 
            final int saleQty = sale[i][1]; // get the sale quantity
            final Integer qty = inv.get(saleProductId); //get the inventory quantity
            if(qty != null && qty >= saleQty){ //if productId is valid and inventory has sufficient quantity
                inv.put(saleProductId, qty-saleQty); //update inventory quantity
            }
        }

        //print results
        for(int productId:inv.keySet()){
            System.out.println(productId+" | "+inv.get(productId));
        }

    }

    private static HashMap<Integer, Integer> initInventory() {
        final HashMap<Integer, Integer> inv = new HashMap<>();
        inv.put(10001, 3);
        inv.put(10002, 33);
        inv.put(10003, 51);
        inv.put(10004, 101);
        inv.put(10005, 4);
        inv.put(10006, 30);
        inv.put(10007, 36);
        inv.put(10008, 8);
        inv.put(10009, 22);
        inv.put(10010, 74);
        inv.put(20001, 24);
        inv.put(20002, 13);
        inv.put(20003, 0);
        inv.put(20004, 62);
        inv.put(20005, 21);
        inv.put(20006, 22);
        inv.put(30001, 59);
        inv.put(30002, 7);
        inv.put(30003, 18);
        inv.put(30004, 44);
        inv.put(30005, 28);
        inv.put(30006, 106);
        inv.put(30007, 23);
        inv.put(30008, 8);
        inv.put(30009, 29);
        inv.put(30010, 7);
        inv.put(30011, 20);
        inv.put(30012, 24);
        inv.put(30013, 55);
        inv.put(30014, 15);
        inv.put(30015, 64);
        inv.put(30016, 15);
        inv.put(30017, 13);
        inv.put(30018, 34);
        inv.put(30019, 44);
        inv.put(30020, 39);
        return inv;
    }

    private static int[][] initSalesData() {
        return new int[][] { 
            {10002, 4},
            {10004, 6},
            {10008, 2},
            {10010, 3},
            {10010, 3},
            {10007, 10},
            {20003, 4},
            {20003, 7},
            {30019, 1},
            {30020, 9},
            {10004, 9},
            {10006, 7},
            {20005, 5},
            {30004, 10},
            {20004, 2},
            {30002, 7},
            {30013, 6},
            {20005, 5},
            {30006, 1},
            {30006, 7},
            {30007, 2},
            {30012, 10},
            {30015, 7},
            {30015, 3},
            {10001, 5},
            {20001, 8},
            {30007, 3},
            {30014, 3},
            {30015, 6},
            {30016, 2},
            {10001, 8},
            {10003, 8},
            {10007, 5},
            {10007, 8},
            {20005, 6},
            {20006, 10},
            {30003, 4},
            {30011, 7},
            {30014, 7},
            {30016, 5},
            {20003, 1},
            {30003, 4},
            {30010, 5},
            {30011, 8},
            {30012, 1},
            {30014, 9},
            {30016, 4},
            {30018, 5},
            {10006, 1},
            {10010, 9},
            {20005, 5},
            {30001, 1},
            {30004, 9},
            {30007, 5},
            {30009, 1},
            {30014, 6},
            {30016, 5},
            {30016, 2},
            {30020, 8},
            {10004, 3},
            {10004, 7},
            {10008, 2},
            {20001, 4},
            {20003, 7},
            {20004, 6},
            {20006, 2},
            {30001, 1},
            {30003, 7},
            {30004, 1},
            {30004, 10},
            {30005, 2},
            {30006, 7},
            {30017, 10},
            {30018, 2},
            {30004, 6},
            {10009, 9},
            {10009, 7},
            {10010, 10},
            {20005, 3},
            {30002, 1},
            {30004, 2},
            {30004, 8},
            {30013, 3},
            {30019, 3},
            {10004, 10},
            {10007, 5},
            {30001, 7},
            {30003, 6},
            {30006, 2},
            {30006, 3},
            {30007, 2},
            {30013, 8},
            {30016, 8},
            {10003, 6},
            {10004, 9},
            {10004, 2},
            {10006, 8},
            {10010, 1},
            {20003, 9},
            {20003, 10},
            {30001, 8},
            {30002, 1},
            {30013, 5},
            {30015, 7},
            {30018, 1},
            {30019, 10},
            {30020, 9},
            {10008, 1},
            {10009, 3},
            {20004, 10},
            {30010, 7},
            {30012, 9},
            {30014, 7},
            {30017, 4},
            {20004, 5},
            {30005, 8},
            {30010, 7},
            {30011, 1},
            {10004, 9},
            {10004, 4},
            {10006, 5},
            {10010, 7},
            {20001, 3},
            {20003, 2},
            {20004, 7},
            {30004, 8},
            {30010, 2},
            {30012, 5},
            {30019, 8},
            {30020, 1},
            {10008, 7},
            {30001, 9},
            {30003, 10},
            {30003, 8},
            {30006, 5},
            {30008, 10},
            {30009, 7},
            {30009, 8},
            {30015, 9},
            {30017, 9},
            {30018, 7},
            {30020, 1},
            {10001, 7},
            {10002, 10},
            {10003, 3},
            {10005, 4},
            {10010, 4},
            {20001, 4},
            {20002, 1},
            {20005, 5},
            {30006, 9},
            {30006, 6},
            {10003, 7},
            {10003, 4},
            {10004, 6},
            {10009, 6},
            {20002, 6},
            {20004, 3},
            {20005, 3},
            {30001, 9},
            {30005, 2},
            {30006, 10},
            {30008, 6},
            {30009, 6},
            {30011, 10},
            {30013, 8},
            {30013, 3},
            {30013, 5},
            {30015, 1},
            {30019, 10},
            {10002, 6},
            {10004, 7},
            {10006, 3},
            {10006, 2},
            {20002, 6},
            {20004, 7},
            {20004, 7},
            {30005, 4},
            {30006, 8},
            {30007, 3},
            {30008, 6},
            {30009, 8},
            {30014, 5},
            {30015, 10},
            {30015, 9},
            {30018, 3},
            {30019, 2},
            {30019, 9},
            {30020, 1},
            {10006, 10},
            {20003, 2},
            {30001, 3},
            {30005, 5},
            {30012, 5},
            {30015, 5},
            {30015, 3},
            {30016, 2},
            {30019, 8},
            {30019, 5}
        };
    }

}

这会产生以下输出：

【讨论】：

抱歉没有说清楚，但是我必须按顺序读取销售数据，没有排序，所以如果库存少于销售的单位，即使库存不为0，我也必须移动到下一个产品 ID。所以我必须遍历销售数据数组，直到相同产品 id 的库存小于已售出的单位，移动到下一个库存项目，然后再次从销售数据数组的开头开始。