避免重复值

Question

I have a range established and I want to select a set of random numbers from that range (10%) while making sure it does not have repeating values.

How and where do I code this within my program?

Below is an extract.

// Number of Items      
int range = numberOfItems [itemNumber - 1];
// Determine 10 percent of the given range
int tenPercentOfRange = (int)(range * 0.1);
int number = 0;
int[] numbers = new int[tenPercentOfRange];

int index = 0;

for(;index < tenPercentOfRange;)
{
  // Randomly select 10% of the items for a given item.
  number = (int) (range * Math.random()) + 1;
  if(!Arrays.asList(numbers).contains(number))
  {
    numbers[index] = number;
    index++; 
    // ..................

Answer 1

The easiest way (though not most efficient) will probably be to populate a list with all elements, use Collections.shuffle() , and select the first 10% elements.

Since the permutation does not have the same entree twice (assuming you populated it this way), the first 10% elements will also be unique, so it fits.

Answer 2

Use collection.shuffle (), and pick a sublist of specified size, or put your values in a List, and remove element at index

found.add (list.remove (random.nextInt (list.size ())); 

for X times. In each step the list is reduced in size, and no element will appear twice.

However, for very big ranges - lets say the range of valid longs, building a list to shuffle or to pick values from isn't appropriate.

So create a Set, and pick random Values, add them to the list until the set.size () is equals the size you need.

Runnable examples:

import java.util.*;

public class Empty {

    static Random random = new Random ();

    public static void main (String args [])
    {
        show (pick (10, 100));
        show (securePick (10, 100000));
    }

    static public List <Integer> pick (int n, int max) {
        List <Integer> result = new ArrayList <Integer> ();
        List <Integer> range = new ArrayList <Integer> (max);
        for (int i= 0; i < max; ++i)
            range.add (i);
        for (int i= 0; i < n; ++i)
            result.add (range.remove (random.nextInt (range.size ()))); 
        return result;
    }

    static public Set <Integer> securePick (int n, int max) {
        Set <Integer> result = new HashSet <Integer> ();
        while (result.size () < n)
            result.add (random.nextInt (max)); 
        return result; // <Integer> 
    }

    public static void show (List <Integer> liste)
    {
        System.out.print ("[");
        for (int i : liste)
            System.out.print (i + ", ");
        System.out.println ("\b\b]");
    }

    public static void show (Set <Integer> liste)
    {
        System.out.print ("[");
        for (int i : liste)
            System.out.print (i + ", ");
        System.out.println ("\b\b]");
    }
}

Answer 3

Your approach with repeating until you get a distinct number is more efficient if you need only 10% of the integer range. This uses LinkedHashSet for efficient check for duplicates.

final int range = 1000, sampleSize = range / 10;
final Set<Integer> rnds = new LinkedHashSet<Integer>();
final Random r = new Random();
for (int i = 0; i < sampleSize;) if (rnds.add(r.nextInt(range) + 1)) i++;
System.out.println(rnds);
final int[] result = new int[sampleSize];
int i = 0;
for (int nr : rnds) result[i++] = nr;