彩票应用NullPointerException定位及号码对比方法优化求助

Hey there! Let's work through your lottery app problems step by step—first squashing that annoying NullPointerException, then sprucing up the number comparison logic to be more efficient.

Looking at your code snippet, the root cause is pretty clear: your lotteryNumbers array is declared but never initialized. You've got:

public static int lotteryNumbers[];

...but no new int[5] (or whatever length you need) to allocate memory for the array. When you try to access or modify lotteryNumbers later in your code, Java throws a NullPointerException because the variable is still pointing to null.

To fix this, initialize the array before you use it—for example, right before you generate the random lottery numbers:

// Inside your main method or number-generation method
Random random = new Random();
lotteryNumbers = new int[5]; // This line is critical!
for (int i = 0; i < lotteryNumbers.length; i++) {
    // Adjust the range here if your lottery uses different number bounds (e.g., 1-50)
    lotteryNumbers[i] = random.nextInt(10);
}

If your lottery doesn't allow duplicate numbers, you can use a Set to generate unique values first, then convert it to an array:

HashSet<Integer> uniqueLotteryNums = new HashSet<>();
while (uniqueLotteryNums.size() < 5) {
    uniqueLotteryNums.add(random.nextInt(10));
}
lotteryNumbers = uniqueLotteryNums.stream().mapToInt(Integer::intValue).toArray();

If you're currently using a nested loop to compare user numbers against lottery numbers (like the example below), you're looking at an O(n²) time complexity—fine for small arrays, but not ideal if you ever scale the number count:

// Example of unoptimized comparison
int matchCount = 0;
for (int userNum : usersNumbers) {
    for (int lotteryNum : lotteryNumbers) {
        if (userNum == lotteryNum) {
            matchCount++;
            break;
        }
    }
}

Here are two better approaches:

Approach 1: Use a HashSet (O(n) Time) #

Store the lottery numbers in a HashSet first—lookups in a HashSet are O(1) on average, so this cuts the comparison time to linear:

import java.util.HashSet;

// ...

HashSet<Integer> lotterySet = new HashSet<>();
for (int num : lotteryNumbers) {
    lotterySet.add(num);
}

int matchCount = 0;
for (int userNum : usersNumbers) {
    if (lotterySet.contains(userNum)) {
        matchCount++;
        // If your lottery doesn't allow duplicates, add this line to avoid counting repeats:
        // lotterySet.remove(userNum);
    }
}

Approach 2: Sort + Double Pointers (O(n log n) Time) #

Sort both arrays first, then use two pointers to traverse them in a single pass. This is great if you want to avoid using extra collections:

import java.util.Arrays;

// ...

Arrays.sort(lotteryNumbers);
Arrays.sort(usersNumbers);

int i = 0, j = 0, matchCount = 0;
while (i < lotteryNumbers.length && j < usersNumbers.length) {
    if (lotteryNumbers[i] == usersNumbers[j]) {
        matchCount++;
        i++;
        j++;
    } else if (lotteryNumbers[i] < usersNumbers[j]) {
        i++;
    } else {
        j++;
    }
}

Both of these methods are way more efficient than nested loops, especially as the number of digits increases.

内容的提问来源于stack exchange，提问作者M.Street