How to protect arrays from changing?

Question

I'm trying to get data from arrays that were used in method fifo and lifo. I have main array that fills from input by user. These array is used in methods fifo and lifo, the problem is that these two functions giving the same priceOfGoods, because while fifo using main array in process it changing data inside it. I want to prevent changing data in ```main array** and use it in two methods without changing data inside main array. Any ideas? Thanks!

public class Solution {
    public static int[][] takingGoodsAndPrice(Scanner input, Integer m) {
        final int[][] goodsAndPrice = new int[m][2];

        // Taking goods and its price
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < 2; j++) {
                goodsAndPrice[i][j] = Integer.parseInt(input.next());
            }
        }
        return goodsAndPrice;
    }

    public static int[] takingAmountOfSales(Scanner input, Integer k) {
        final int[] amountOfSales = new int[k];

        // Taking sale of goods
        for (int i = 0; i < k; i++) {
            amountOfSales[i] = Integer.parseInt(input.next());
        }

        return amountOfSales;
    }

    public static Integer fifo(Integer k, Integer m, int[][] goodsAndPrice, int[] amountOfSales) {
        int priceOfRestGoods = 0;
        int[][] goods = goodsAndPrice;
        int[] amount = amountOfSales;

        // Evaluates amount of goods that were not sold
        for (int i = 0; i < k; i++) {
            for (int j = 0; j < m; j++) {
                if (amount[i] == 0)
                    break;

                if (goods[j][0] > amount[i]) {
                    goods[j][0] = goods[j][0] - amount[i];
                    amount[i] = amount[i] - amount[i];
                } else if (goods[j][0] <= amount[i]) {
                    amount[i] = amount[i] - goods[j][0];
                    goods[j][0] = 0;
                }
            }
        }

        // Evaluates price of goods that were not sold
        for (int i = 0; i < m; i++) {
            priceOfRestGoods = priceOfRestGoods + (goods[i][0] * goods[i][1]);
        }

        return priceOfRestGoods;
    }

    public static Integer lifo(Integer k, Integer m, int[][] goodsAndPrice, int[] amountOfSales) {
        int priceOfRestGoods = 0;

        // Evaluates amount of goods that were not sold
        for (int i = 0; i < k; i++) {
            for (int j = m-1; j >= 0; j--) {
                if (amountOfSales[i] == 0)
                    break;

                if (goodsAndPrice[j][0] > amountOfSales[i]) {
                    goodsAndPrice[j][0] = goodsAndPrice[j][0] - amountOfSales[i];
                    amountOfSales[i] = amountOfSales[i] - amountOfSales[i];
                } else if (goodsAndPrice[j][0] <= amountOfSales[i]) {
                    amountOfSales[i] = amountOfSales[i] - goodsAndPrice[j][0];
                    goodsAndPrice[j][0] = 0;
                }
            }
        }

        // Evaluates price of goods that were not sold
        for (int i = 0; i < m; i++) {
            priceOfRestGoods = priceOfRestGoods + (goodsAndPrice[i][0] * goodsAndPrice[i][1]);
        }

        return priceOfRestGoods;
    }
//
//    public static Integer medium() {
//
//    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        final int n = input.nextInt(); // n - total amount of goods
        final int m = input.nextInt(); // m - total amount of goods that has been received
        final int k = input.nextInt(); // k - total amount of goods that has been released

        final int[][] goodsAndPrice = takingGoodsAndPrice(input, m);
        final int[] amountOfSales = takingAmountOfSales(input, k);

        System.out.println(fifo(k, m, goodsAndPrice, amountOfSales));
        System.out.println(lifo(k, m, goodsAndPrice, amountOfSales));
    }
}

You can make a copy of the array and pass the copy to methods `fifo` or `lifo`. — kevinjom, Jun 06 '20 at 13:24

score 1 · Accepted Answer · answered Jun 06 '20 at 13:31

At the moment, you're creating new variables to store the arrays, but they will reference the same array done like this, meaning that any changes made to them will also be present in the original parameters. You'll want to store a copy of the arrays in those variables instead. See here.

score 1 · Answer 2 · answered Jun 06 '20 at 13:40

When you do the following

int[][] goods = goodsAndPrice;

you are still referencing the values referenced by goodsAndPrice i.e. both goods and goodsAndPrice will reference the same values. Therefore, any changes made using one of these references will be same for the other reference.

What you need to do is to create a copy of goodsAndPrice[][] and make changes to the copy. You can do create a copy of goodsAndPrice[][] as follows:

int[][] goods = Arrays.stream(goodsAndPrice).map(int[]::clone).toArray(int[][]::new);

How to protect arrays from changing?

2 Answers2