Java random integer generation and frequency statistics: simulation experiments and result analysis

This article aims to guide readers how to use Java to generate random integers within a specified range and perform frequency statistics and analysis of these random numbers. We will explore the characteristics of random numbers, how to implement a general method of generating random numbers and counting occurrences, and further analyze the most common numbers and the distribution of odd and even numbers, and finally provide a complete example code to help readers understand and apply these concepts.

1. Understand randomness and random number generation

In programming, generating random numbers is a common requirement, such as simulated throwing coins, rolling dices, etc. However, the understanding of "random" can sometimes lead to misunderstandings. True randomness means that the probability of each result appearing is independent, and in small sample sizes, the distribution of the results may appear uneven, and even continuous identical results appear. For example, it is possible to throw a coin 10 times in a row, 5 front and 5 reverses, but 8 front and 2 reverses are also completely random. Only under large sample sizes can the distribution of the results approach a theoretically uniform distribution.

Java provides the Math.random() method to generate a double type random number in the range [0.0, 1.0). To generate integers within the specified range [a, b], you can use the following formula:

 (int) (Math.random() * (b - a 1) a)

For example, generate a random integer between 1 and 10:

 int randomNumber = (int) (Math.random() * 10 1); // Generate an integer of [1, 10]

To better encapsulate this logic, we can create a common method:

 /**
 * Generates a random integer (including min and max) within the specified range [min, max].
 * @param min minimum value * @param max maximum value * @return Random integers in range */
public static int generateRandomInteger(int min, int max) {
    return (int) (Math.random() * (max - min 1) min);
}

2. Store and count random numbers

After a series of random numbers are generated, they are usually stored and the frequency of occurrence of each number is counted.

2.1 Store random numbers

We can use an int array or List to store the generated random numbers. ArrayList is a better choice if flexible capacity is required.

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

// ... int numberOfFlips = 1000 in the main method or elsewhere; // Number of simulations List<integer> results = new ArrayList(numberOfFlips);
for (int i = 0; i <h4> 2.2 Number of statistics occurrences</h4>
<p> There are several ways to count the occurrence of each number:</p>
<ul>
<li> <strong>Use arrays:</strong> If the range of random numbers is fixed and small, you can directly use an array as the frequency counter. The index of the array corresponds to a random number, and the value of the array stores the number of occurrences.</li>
<li> <strong>Use HashMap:</strong> For any range of random numbers or uncertain ranges of random numbers, HashMap<integer integer> is a more flexible choice, the key is a random number and the value is an occurrence.</integer>
</li>
</ul>
<p> Here we take HashMap as an example because it is more general.</p>
<pre class="brush:php;toolbar:false"> import java.util.HashMap;
import java.util.Map;

/**
 * Statistics the number of occurrences of each number in the list.
 * @param numbers List of random numbers* @return A Map, the key is a number, and the value is its occurrence number*/
public static Map<integer integer> countOccurrences(List<integer> numbers) {
    Map<integer integer> occurs = new HashMap();
    for (int num : numbers) {
        occurrences.put(num, occurrences.getOrDefault(num, 0) 1);
    }
    return occurrences;
}</integer></integer></integer>

If you need to count the number of occurrences of a specific value n in a given array arr, you can implement an auxiliary method:

 /**
 * Statistics the number of occurrences of the specified value n in the given array arr.
 * @param n Value to count* @param arr Integer array* @return Number of times value n appears in the array*/
public static int countValueInArray(int n, int[] arr) {
    int count = 0;
    for (int value : arr) {
        if (value == n) {
            count ;
        }
    }
    return count;
}

Note: In actual applications, if you already have frequency statistics in the form of Map, it will be more efficient to directly obtain a number from the Map than to traverse the entire original array. The countValueInArray method is suitable for scenarios where a single query is required to be performed on the original array.

3. Results analysis and extension functions

After counting the occurrence of each number, we can further analyze these data to meet specific needs.

3.1 Report the number of occurrences of each number

By traversing the statistical results Map, you can print the number of occurrences of each number.

 public static void printOccurrences(Map<integer integer> occurrences) {
    System.out.println("--- The frequency of digital occurrence----");
    for (Map.Entry<integer integer> entry : occurences.entrySet()) {
        System.out.println(entry.getKey() ": " entry.getValue() " times");
    }
}</integer></integer>

3.2 Find the number that appears the most

Traversing the statistical result Map, recording the number with the most occurrences and the number of times.

 public static void findMostFrequentNumber(Map<integer integer> occurs) {
    int mostFrequentNum = -1;
    int maxCount = -1;

    for (Map.Entry<integer integer> entry : occurences.entrySet()) {
        if (entry.getValue() > maxCount) {
            maxCount = entry.getValue();
            mostFrequentNum = entry.getKey();
        }
    }
    if (mostFrequentNum != -1) {
        System.out.println("The number with the most occurrences is: " mostFrequentNum " (" maxCount " times)");
    } else {
        System.out.println("No number was counted.");
    }
}</integer></integer>

3.3 Analyze the frequency of odd and even numbers (simulate the front and back of the coin)

If we treat even numbers as "positive" and odd numbers as "negative", we can count their occurrences separately.

 public static void analyzeEvenOddOccurrences(Map<integer integer> occurrences) {
    int evenCount = 0;
    int oddCount = 0;

    for (Map.Entry<integer integer> entry : occurences.entrySet()) {
        if (entry.getKey() % 2 == 0) {
            evenCount = entry.getValue();
        } else {
            oddCount = entry.getValue();
        }
    }

    System.out.println("--- Odd and even statistics---");
    System.out.println("even number (front) occurrences: " evenCount " times");
    System.out.println("oddCount (reverse) Number of occurrences: " oddCount " times");

    if (evenCount > oddCount) {
        System.out.println("even (front) appears more times.");
    } else if (oddCount > evenCount) {
        System.out.println("Odd number (reverse) appears more times.");
    } else {
        System.out.println("Odd and even numbers appear the same number of times.");
    }
}</integer></integer>

4. Complete sample code

Integrate all the above functions into a complete Java program, simulate the number of throws entered by the user and conduct a comprehensive statistical analysis.

 import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class RandomNumberAnalysis {

    // 1. Create and use a method to generate a random integer within the specified range [a, b] public static int generateRandomInteger(int min, int max) {
        return (int) (Math.random() * (max - min 1) min);
    }

    // 2. Create and use a method to count the number of occurrences of a specific value n in a given array arr // Here, in order to adapt to List<integer>, we use List as the parameter public static int countValueInList(int n, List<integer> list) {
        int count = 0;
        for (int value : list) {
            if (value == n) {
                count ;
            }
        }
        return count;
    }

    /**
     * Statistics the number of occurrences of each number in the list.
     * @param numbers List of random numbers* @return A Map, the key is a number, and the value is its occurrence number*/
    public static Map<integer integer> countAllOccurrences(List<integer> numbers) {
        Map<integer integer> occurs = new HashMap();
        for (int num : numbers) {
            occurrences.put(num, occurrences.getOrDefault(num, 0) 1);
        }
        return occurrences;
    }

    /**
     * Print the frequency of occurrence of each number.
     * @param occurrences Map containing numbers and their occurrences
     * @param minNum Minimum value of the range of random numbers* @param maxNum Maximum value of the range of random numbers*/
    public static void printAllOccurrences(Map<integer integer> occurrences, int minNum, int maxNum) {
        System.out.println("\n--- The frequency of occurrence of each number---");
        for (int i = minNum; i  occurs) {
        int mostFrequentNum = -1;
        int maxCount = -1;

        for (Map.Entry<integer integer> entry : occurences.entrySet()) {
            if (entry.getValue() > maxCount) {
                maxCount = entry.getValue();
                mostFrequentNum = entry.getKey();
            }
        }
        if (mostFrequentNum != -1) {
            System.out.println("\nThe number with the most occurrences is: " mostFrequentNum " (" maxCount " times)");
        } else {
            System.out.println("\nNo number was counted.");
        }
    }

    /**
     * Analyze the frequency of odd and even numbers.
     * @param occurrences Map containing numbers and their occurrences
     */
    public static void analyzeEvenOddOccurrences(Map<integer integer> occurrences) {
        int evenCount = 0;
        int oddCount = 0;

        for (Map.Entry<integer integer> entry : occurences.entrySet()) {
            if (entry.getKey() % 2 == 0) {
                evenCount = entry.getValue();
            } else {
                oddCount = entry.getValue();
            }
        }

        System.out.println("\n--- Odd and even statistics (even number = front, odd number = reverse) ---");
        System.out.println("even number (front) occurrences: " evenCount " times");
        System.out.println("oddCount (reverse) Number of occurrences: " oddCount " times");

        if (evenCount > oddCount) {
            System.out.println("Conclusion: Even (positive) appears more times.");
        } else if (oddCount > evenCount) {
            System.out.println("Conclusion: Odd number (reverse) appears more times.");
        } else {
            System.out.println("Conclusion: Odd and even numbers appear the same number of times.");
        }
    }

    public static void main(String[] args) {
        try (Scanner inputReader = new Scanner(System.in)) {
            System.out.print("Please enter the number of throws you want to simulate (for example, 1000): ");
            int amount = inputReader.nextInt();

            if (amount  generatedNumbers = new ArrayList(amount);
            for (int i = 0; i  occurrencesMap = countAllOccurrences(generatedNumbers);
            printAllOccurrences(occurrencesMap, MIN_RANDOM, MAX_RANDOM);

            // 2. Find the number with the most occurrences findMostFrequentNumber(occurrencesMap);

            // 3. Analyze the occurrence frequency of odd and even numbers analyzeEvenOddOccurrences(occurrencesMap);

            // Example: Use countValueInList method to count the occurrence of a specific number System.out.println("\n--- Single numeric statistics example---");
            int specificNumber = 5;
            System.out.println("number" specificNumber " appears" countValueInList(specificNumber, generatedNumbers) " times.");

        } catch (Exception e) {
            System.err.println("Error occurred: " e.getMessage());
        }
    }
}</integer></integer></integer></integer></integer></integer></integer></integer></integer>

5. Precautions and summary

• Random understanding: Even if it is “random”, small sample sizes may have uneven distribution. This is an inherent feature of random numbers, not a program error. As the number of simulations (sample size) increases, the results will become closer to the theoretical uniform distribution.
• java.util.Random: Math.random() uses the default instance of java.util.Random internally. If better randomness control is needed (for example, using specific seeds to generate reproducible random sequences), you can create a java.util.Random object directly.

   import java.util.Random;
  // ...
  Random rand = new Random(); // or new Random(seed)
  int randomNumber = rand.nextInt(max - min 1) min; // Generate an integer of [min, max]

• Debugging skills: When the program behavior does not meet expectations, learning to use System.out.println() to output variable values ​​at key points, or using the IDE's debugger (set breakpoints, step by step, view variables) to track program execution process and data changes, which is an effective means to locate problems.

Through the study of this article, you should have mastered the method of generating random integers within a specified range in Java and conducting comprehensive statistics and analysis of these random numbers. These skills are very practical in simulation, game development, data analysis and other fields.

The above is the detailed content of Java random integer generation and frequency statistics: simulation experiments and result analysis. For more information, please follow other related articles on the PHP Chinese website!