生成唯一的随机整数集

Question

这是我第一次构建应用程序，但遇到了问题。我正在制作这个应用程序，它只会生成随机数，有时它会向我显示两次随机数。这不是我的目标，那么如何对其进行编程以显示随机数而不重复？

这是我的代码：

    package rando.mizer;

    import java.util.Random;

    import android.app.Activity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.EditText;

    public class RandomizerFinalActivity extends Activity {
        /** Called when the activity is first created. */   
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            Button buttonGenerate = (Button)findViewById(R.id.button1);
            final EditText aantalT= (EditText)findViewById(R.id.editText1);
            final EditText laagsteT = (EditText)findViewById(R.id.editText2);
            final EditText hoogsteT = (EditText)findViewById(R.id.editText3);
            final EditText uitvoerT = (EditText)findViewById(R.id.editText4); 



            buttonGenerate.setOnClickListener(new Button.OnClickListener(){

               public void onClick(View arg0) {
                    final int aantal = Integer.parseInt(aantalT.getText().toString());
                    final int laagste = Integer.parseInt(laagsteT.getText().toString());
                    final int hoogste = Integer.parseInt(hoogsteT.getText().toString());

                    uitvoerT.setText("");
                    Random r = new Random();

                    int aNumber;
                    String build = "";


                for(int i = 0; i < aantal; i++) {
                    aNumber = laagste + r.nextInt(hoogste + 1 - laagste);
                    build += aNumber + ",\n";
                }

                    uitvoerT.setText(build);


              }

            });
        }
    }

Answer 1

使用 Collections.shuffle 是个好主意，但您不需要随机播放所有数字。使用起来会更有效率：

// return nNumbers distinct values from low to (high - 1)
public List<Integer> getRandoms(int low, int high, int nNumbers) {
    int range = high - low;
    List<Integer> workArray = new ArrayList(range);
    for (Integer i = low; i < high; i++)
        workArray.add(i);

    // Put the chosen values at the start of the array one by one 
    // (and then do not touch the start of the array).
    int pseudoStartIndex = 0;
    while (pseudoStartIndex < nNumbers) {
        int randomIndex = pseudoStartIndex + 
                          random.nextInt(range - pseudoStartIndex); 
        Integer tempSwap = workArray.get(pseudoStartIndex);
        workArray.set(pseudoStartIndex, workArray.get(randomIndex));
        workArray.set(randomIndex, tempSwap);
        pseudoStartIndex++;
    }
    return workArray.subList(0, nNumbers);
}

它基本上是Fisher-Yates shuffle，但只应用于少数元素。

Answer 2

您似乎正在尝试从已知集合中随机选择不重复的数字，例如在彩票中所做的那样。如果集合不是太大，这种方法会起作用（请注意，如果计数大于数字的数量，它将失败）。

/** Will pick `count` numbers randomly from the set of numbers between
 * startNumber (included) and endNumber (excluded). */
public static Collection<Integer> randomPick(int startNumber, int endNumber, int count) {
    // Generate a list of all numbers from start to endNumber
    List<Integer> numbers = new ArrayList<Integer>();
    for(int i = startNumber; i < endNumber; i++) {
        numbers.add(i);
    }

    // Shuffle them
    Collections.shuffle(numbers);

    // Pick count items.
    return numbers.subList(0, count);
}

Answer 3

你的问题是你总是使用相同的种子，所以生成相同数字的机会非常高，首先你需要了解生成纯随机数是不可能的，Java给你的是一个漂亮的不错的机制，但依赖于种子。

一种常见的做法是以毫秒为单位使用当前日期时间，因此，如果您这样做：

new Random(System.currentTimeMillis())

你会发现你没有得到重复。您可以使用以下代码进行尝试：

public static void main (String... args){
   for (int i=0; i<10000; i++){
       try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
       Random random = new Random(System.currentTimeMillis());
       System.out.println(random.nextInt());

   }
}

Answer 4

如果您创建和初始化（使用种子）一次 Random 对象会更好，而不是在每次调用您的 Listener 时创建随机对象，这样就不太可能有重复的数字。

Answer 5

import java.util.Set;

Set<Integer> mySet = new HashSet<Integer>(10); // do you know how many elements do you need?
boolean elementNotThere;
do {
    int myInt = r.nextInt(hoogste + 1 - laagste);
    elementNotThere = mySet.add(myInt);
} while ( ! elementNotThere );