Why does sorting my array always make the first two index values a zero?

What I am trying to get is a random number generator that will produce five lines of 5 random numbers 1 through 70 and one more number 1 through 25 like a mega millions ticket.

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;

public class MegaMillions {
    
	public void play() {
		Random rand = new Random();
		int[] numbers = new int[5];
		for(int i = 0; i < 5; i++) {
			numbers[i] = rand.nextInt(69) + 1;
			Collections.shuffle(Arrays.asList(numbers));
			Arrays.sort(numbers);
			System.out.print(numbers[i] + " ");
		}
		Collections.shuffle(Arrays.asList(numbers));
		int megaBall = rand.nextInt(24) + 1;
		System.out.println("(" + megaBall + ")");
	}

}

Here is an example of what I'm getting:

0 0 21 21 35 (1)

0 0 16 26 32 (9)

0 0 39 39 53 (3)

0 0 22 37 51 (14)

0 0 18 18 60 (14)

My understanding was that Collections.shuffle should take care of any repeating integers and Arrays.sort should put in numerical order.

> Collections.shuffle(Arrays.asList(numbers));

Okay, your numbers array is now shuffled. Immediate next line:

> Arrays.sort(numbers);

... and now it's sorted again. There was no point whatsoever in shuffling first if you're going to sort right after. It seems clear you misunderstand what these calls do or how your algorithm works, but exactly how you misunderstand these things isn't clear from your question.

Why do I get two zeroes?

Because that's exactly what your algorithm does. The computer just does what you tell it to.

Let's go through an example:

1. You start with a new 5-sized array; [0, 0, 0, 0, 0].
2. loop 5 times.
3. (loop1) Set the 0-index to a random number: [50, 0, 0, 0, 0].
4. (loop1) Shuffle the list. Irrelevant, we'll sort it afterwards.
5. (loop1) sort it: [0, 0, 0, 0, 50].
6. (loop1) print the 0-index number. This is always 0.
7. (loop2) Set the 1-index to a random number: [0, 45, 0, 0, 50].
8. (loop2) Shuffle the list. Irrelevant, we'll sort it afterwards.
9. (loop2) sort it: [0, 0, 0, 45, 50].
10. (loop2) print the 1-index number. This is always 0.
11. (loop3) Set the 2-index to a random number: [0, 0, 47, 45, 50].
12. (loop3) Shuffle the list. Irrelevant, we'll sort it afterwards.
13. (loop3) sort it: [0, 0, 45, 47, 50].
14. (loop3) print the 2-index number. This prints '45'.

And so on.

It seems rather likely that you don't want to shuffle and you don't want to sort.

You want to just fill each slot with a random number and that is all.

If you want the 5 numbers to be sorted - just sort once, afterwards. If you want to print the numbers in sorted order, first fill the entire array and print nothing - then sort it, then loop through to print it, then add the 1-25 number as final step and print that.

Originally you have an array like

[0,0,0,0,0]

you do numbers[i] = rand.nextInt(69) + 1;

and may end up with
[21,0,0,0,0]

then you do Arrays.sort(numbers);

which will change to [0,0,0,0,21]

next [0,12,0,0,21] -> [0,0,0,12,21]

next [0,0,7,12,21] -> [0,0,7,12,21]

Your code is... odd.

The first time through the loop, ou put the first random number in the array at index 0, shuffle the array (putting the number 'somewhere'), and then sort the array (putting the number in the last place, guaranteed because the other 4 numbers are each 0). Index 0 is 0 after this.

Then repeat with second number, which goes into index 1. Note that the zero index stays zero. Shuffle, and sort again. The first three numbers will be zero; they have to be, because there are only 2 non-zero numbers in the array.

Now the third number. Note that index 0 and index 1 remain zero.

Etc.

Summary: shuffling and then sorting is pointless, since the sort undoes any randomization that shuffling did.

And sorting inside the loop is pointless too, since it is moving non-zero numbers to where they can eventually be overwritten, and guaranteeing some zeroes that won't be.

Guessing that you want to print out each 'ball' as it is generated, and then print them all out in sorted order:

 for (int i = 0; i < 5; i++) {
     numbers[i] = rand.nextInt(69) + 1;
     System.out.print(numbers[i] + " ");
 }
 System.out.println();
 
 Arrays.sort(numbers);
 for (int i = 0; i < 5; i++) {
     System.out.print(numbers[i] + " ");
 }
 System.out.println();

This is liable to having repeated random numbers, but dealing with that should be another question.

> "Why does sorting my array always make the first two index values a zero? ..."

This is because you're sorting numbers on each iteration.

The first and second iterations would yield a numbers array where elements 0 and 1 are zero.

> "... What I am trying to get is a random number generator that will produce five lines of 5 random numbers 1 through 70 and one more number 1 through 25 like a mega millions ticket. ..."

To get 5 unique random numbers, create a List of values 1 through 70, and use Collections#shuffle.

int[] numbers = new int[6];
List<Integer> list = new ArrayList<>();
for (int value = 1; value <= 70; value++) list.add(value);
Collections.shuffle(list);
for (int index = 0; index < 5; index++)
    numbers[index] = list.get(index);
numbers[5] = new Random().nextInt(1, 26);

Output

51 11 30 59 44 (13)

> "... My understanding was that Collections.shuffle should take care of any repeating integers ..."

No, shuffle just re-orders the list.
You may be thinking of a Set, which will only allow unique values.

I switched a few things around and it seems to work. In order to get the results that I had intend I simply cut the Collections.shuffle and Arrays.sort lines and pasted directly below the for loop. Then, beneath that, I added another for loop that loops five times printing numbers[i]. Also the final Collections.shuffle wasn't necessary for the mega ball.

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;

class Main {
    public static void main(String[] args) {
        MegaMillions megamillions = new MegaMillions();
        for(int i = 0; i < 5; i++) {
            megamillions.play();
        }
    }
}    
class MegaMillions {
    public void play() {
        Random rand = new Random();
        int[] numbers = new int[5]; 
        for(int i = 0; i < 5; i++) {
            numbers[i] = rand.nextInt(69) + 1;
        }
        Collections.shuffle(Arrays.asList(numbers));
        Arrays.sort(numbers);
        for(int i = 0; i < 5; i++) {
            System.out.print(numbers[i] + " ");
        }
        int megaBall = rand.nextInt(24) + 1;
        System.out.println("(" + megaBall + ")"); 
    }
}
```


</details>



# 答案6
**得分**: 0

答案在使用Arrays.sort(numbers)方法对数组进行排序。假设你的值如下所示：

0索引循环 [10,0,0,0,0]

然后你执行Arrays.sort(numbers);

你将得到以下数组 [0,0,0,0,10]

1索引循环 [0,12,0,0,10] -> [0,0,0,10,12]

2索引循环 [0,0,15,10,12] -> [0,0,10,12,15]

游戏从这里开始对吧？
3索引循环 [0,0,10,21,15]->[0,0,10,15,21]

当你将元素添加到numbers[i]中时，实际上填充了索引为3的值，排序后变为[0,0,10,15,21]。所以在循环结束之前，索引0和1将始终为零。

如果增加数组numbers的长度，索引为零的位置也会增加。

<details>
<summary>英文:</summary>

The answer lies in the sorting of array using Arrays.sort(numbers) method.
lets suppose your values is like below

0 index loop  [10,0,0,0,0]

then you do Arrays.sort(numbers);

you will get the array like this [0,0,0,0,10]

1 index loop [0,12,0,0,10] -&gt; [0,0,0,10,12]

2 index loop [0,0,15,10,12] -&gt; [0,0,10,12,15]

the game begins from here right?
3 index loop [0,0,10,21,15]-&gt;[0,0,10,15,21]

when you add elements in numbers[i] this actually fills the 3 index value which after sorting becomes [0,0,10,15,21].so index 0 and 1 will become always zero while looping until loop ends.

if you increase the length of the array numbers then index with zero will also increase.



</details>