Biased Random Number Generator

I am looking for a random number generator that is biased towards giving numbers "furthest away" from a set of already selected numbers. 
For example, if my range is [1, 50] and I pass in a set of numbers such as (1, 20, 40), 
then I would want the generator to "prefer" producing numbers further away from 1, 20, and 40.
 Therefore, numbers such as 50 or 30 would be more likely to be drawn than 20 or 40. 
I suspect that this may already exist. Does anyone know of such an implementation that I can use for Java?

Here is a way you can do it by hand. Basically the idea is we take in some numbers we don't want to generate, then we generate a random number and if that number is in the list of numbers we don't want we try again up to a maximum number of retries.

public static void main(String[] args) {

        int times = 25;
        int[] listOfNumbers = {1, 2, 3};
        int max = 5, min = 1;

        while(times-- > 0)
        {   
            System.out.print(GeneratePreferredNumbers(listOfNumbers, max, min) + " ");
        }


    }//main method

    public static Integer GeneratePreferredNumbers(int[] listOfNotPreffered, int max, int min)
    {
        Random rand = new Random();
        int randomNum;
        int retry = 1; //increasing this lessons the likely of our non-preferred numbers to show up
        HashSet<Integer> notPrefer = new HashSet<>();

        //add all the numbers we don't want to generate into a HashSet for easy lookup
        for(int index = 0; index < listOfNotPreffered.length; index++)
            notPrefer.add(listOfNotPreffered[index]);

        do {
            randomNum = rand.nextInt((max - min) + 1) + min;
            if(notPrefer.contains(randomNum))
            {
                retry--;
            }
            //we found a good value, let's return it
            else{
                retry = 0;
            }
        } while (retry > 0);

        return randomNum;
    }

　　NOTE: The more times we allow the algorithm to retry the more likely our output will consist of numbers we want. This allows you to control how likely you want those non-preferred numbers to show up. This makes sense because if we were to increase the retry to infinite, this would stop only when the number generated is not contained in our list non-preferred numbers.