如何将数组中存储的值用于另一个方法进行计算？

Hey there! Let's walk through how to pass array-stored values to another method for calculations, using your dice roll code as a concrete example.

First, let's fix and expand your incomplete code to show the pattern clearly. The core idea is:

• Store your dice roll values in an array (either the one passed into diceRoll, or a new array you create)
• Pass that array to a separate method dedicated to handling the calculation logic

Step 1: Complete the Dice Roll Logic & Integrate Arrays #

Here's a revised version of your code that uses arrays to hold dice rolls and passes them to a calculation method:

public class DiceGame {
    // Updated diceRoll method with array handling
    static void diceRoll(int[] val) {
        // Populate the input array with 4 dice rolls (if valid)
        if (val != null && val.length == 4) {
            for (int i = 0; i < val.length; i++) {
                // Simplified random dice roll (gives values 1-6)
                val[i] = (int) (Math.random() * 6 + 1);
            }
        } else {
            // Fallback: create a new array if input is invalid
            val = new int[4];
            for (int i = 0; i < 4; i++) {
                val[i] = (int) (Math.random() * 6 + 1);
            }
        }

        // Pass the array of rolls to our calculation method
        int total = calculateTotal(val);
        System.out.println("Total (after removing smallest roll): " + total);
    }

    // Separate method to handle the sum calculation logic
    static int calculateTotal(int[] rolls) {
        int total = 0;
        int smallest = rolls[0];

        // First find the smallest value in the array
        for (int roll : rolls) {
            if (roll < smallest) {
                smallest = roll;
            }
        }

        // Sum all values except one instance of the smallest
        boolean smallestRemoved = false;
        for (int roll : rolls) {
            if (roll == smallest && !smallestRemoved) {
                smallestRemoved = true;
                continue;
            }
            total += roll;
        }

        return total;
    }

    // Test the code
    public static void main(String[] args) {
        int[] diceRolls = new int[4];
        diceRoll(diceRolls);
        // The diceRolls array now holds the generated values, ready for reuse!
    }
}

Step 2: Key Concepts Breakdown #

• Array Passing in Java: When you pass an array to a method (like calculateTotal(val)), you're passing a reference to the original array. This means the method can read (and modify, if needed) the array's values directly—no need to copy the entire array.
• Separation of Concerns: Splitting dice rolling and calculation into separate methods makes your code cleaner, easier to test, and reusable. For example, you could use calculateTotal for any set of 4 dice rolls, not just the ones generated in diceRoll.
• Flexible Array Usage: The code checks if the input val array is valid (non-null and length 4) before populating it. If not, it creates a new array—giving you the option to pass an existing array to be filled, or let the method handle array creation.

Alternative: Passing Pre-Stored Array Values #

If you already have an array of pre-generated dice rolls, you can modify the code to accept and process that array directly:

public class DiceGame {
    static void processPreRolledValues(int[] preRolled) {
        if (preRolled == null || preRolled.length != 4) {
            System.out.println("Invalid dice roll array!");
            return;
        }

        int total = calculateTotal(preRolled);
        System.out.println("Total from pre-stored rolls: " + total);
    }

    // Reuse the same calculateTotal method
    static int calculateTotal(int[] rolls) {
        // ... same logic as above ...
    }

    public static void main(String[] args) {
        // Example pre-stored dice rolls
        int[] myRolls = {3, 1, 5, 4};
        processPreRolledValues(myRolls); // Pass the pre-stored array for calculation
    }
}

This works because arrays in Java are reference types—when you pass them to a method, both the caller and the method access the same underlying data.

内容的提问来源于stack exchange，提问作者Samasha