Java随机数使用实例总结

Java中提供了好几个类，可以让我们方便的实现随机数等功能，这些类有java.util.Random, java.util.UUID 以及JDK 7 新引入的java.util.concurrent.ThreadLocalRandom等。

本文将通过这些类对平时使用的实例进行简单的总结，这些实例的功能大致可以分成四个方面：

1. 随机产生N个指定范围内[Min,Max)的随机数

/**
	 * 使用java.util.Random产生一个长度为expectedNum的随机数组，随机数的范围[min,max)
	 */
	public int[] gerateRandomArrayWithRange1(int min, int max, int expectedNum) {
		int[] randomArray = new int[expectedNum];
		Random random = new Random();
		for (int i = 0; i < expectedNum; i++) {
			randomArray[i] = random.nextInt(max - min) + min;
		}
		return randomArray;
	}
	
	/**
	 * JDK 7 引入java.util.concurrent.ThreadLocalRandom,使用ThreadLocalRandom可以让产生范围内的随机数变得更加方便。
	 */
	public int[] gerateRandomArrayWithRange2(int min, int max, int expectedNum) {
		int[] randomArray = new int[expectedNum];
		for (int i = 0; i < expectedNum; i++) {
			randomArray[i] = ThreadLocalRandom.current().nextInt(min, max);
		}
		return randomArray;
	}

2. 随机生成和为S的N个正整数

/**
	 * 随机产生和为S的N个随机正整数
	 * 
	 * 思路：
	 * 第一步：把和为S的数值看做是一把尺子的长度，比如S=20。
	 * 那么随机产生和为S的N个整数的问题就变成了在0~20之间产生N-1不同的刻度。这样的话，尺子就被不同的刻度分割成了N段。
     * 第二步：从左到右，计算出每一段的长度，每一段的长度就可以看做是随机数。N段就有了N个随机数。
	 */
	public int[] generateRandomArray(int expectedSum, int expectedNum, boolean ordered) {
		
		Set<Integer> set = new TreeSet<Integer>();
		/*
		 * 先将最两端的刻度加入到集合中去。 
		 */
		set.add(0);
		set.add(expectedSum);
		
		Random random = new Random();
		while (set.size() < expectedNum + 1) {
			set.add(random.nextInt(expectedSum - 1) + 1);
		}
		
		Integer[] locations = new Integer[set.size()];
		set.toArray(locations);
		
		int[] result = new int[expectedNum];
		/*
		 * 计算相邻刻度之间的长度，得到的数值就可以认为是随机数:
		 */
		for (int i = 0; i < result.length; i++) {
			result[i] = locations[i + 1] - locations[i];
		}
		
		/*
		 * 如果想让得到的随机数从小到大排列，则调用Arrays.sort
		 */
		if(ordered)
		{
			Arrays.sort(result);
		}
		return result;
	}

  随机生成和为S的N个正整数的部分也可以参考如下的博文：
http://mouselearnjava.iteye.com/blog/1858974

3. 随机获取唯一的标识字符串

/**
	 * 直接调用UUID获取随机字符串(包含'-')
	 * 
	 * 可用作数据库表的主键
	 * 
	 * 如： 53b25837-05f1-4be2-9c81-2f8bc898f6bd
	 */
	public String randomUUID1()
	{
		return UUID.randomUUID().toString();
	}
	
	/**
	 * 直接调用UUID获取随机字符串(不包含'-')
	 * 
	 * * 可用作数据库表的主键
	 * 
	 * 如： 97013848ac764487b01d0470cdde3f1a
	 */
	public String randomUUID2()
	{
		return UUID.randomUUID().toString().replaceAll("-", "");
	}

这样随机产生的UUID字符串可用作数据库表的主键。

4. 使用Collections.shuffle随机打乱指定List的顺序

/**
	 * 使用Collections的shuffle方法，将已有的List顺序随机打乱。
	 */
	public void shuffle(List<?> list) {
		Collections.shuffle(list);
	}

这样的方法可用于洗牌等方面。

洗牌的博文也可以参考：http://mouselearnjava.iteye.com/blog/1858970

实现上述功能的类的详细内容如下：

package my.random;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;

public class RandomUtils {

	/**
	 * 使用java.util.Random产生一个长度为expectedNum的随机数组，随机数的范围[min,max)
	 */
	public int[] gerateRandomArrayWithRange1(int min, int max, int expectedNum) {
		int[] randomArray = new int[expectedNum];
		Random random = new Random();
		for (int i = 0; i < expectedNum; i++) {
			randomArray[i] = random.nextInt(max - min) + min;
		}
		return randomArray;
	}
	
	/**
	 * JDK 7 引入java.util.concurrent.ThreadLocalRandom,使用ThreadLocalRandom可以让产生范围内的随机数变得更加方便。
	 */
	public int[] gerateRandomArrayWithRange2(int min, int max, int expectedNum) {
		int[] randomArray = new int[expectedNum];
		for (int i = 0; i < expectedNum; i++) {
			randomArray[i] = ThreadLocalRandom.current().nextInt(min, max);
		}
		return randomArray;
	}

	/**
	 * 随机产生和为S的N个随机正整数
	 * 
	 * 思路：
	 * 第一步：把和为S的数值看做是一把尺子的长度，比如S=20。
	 * 那么随机产生和为S的N个整数的问题就变成了在0~20之间产生N-1不同的刻度。这样的话，尺子就被不同的刻度分割成了N段。
     * 第二步：从左到右，计算出每一段的长度，每一段的长度就可以看做是随机数。N段就有了N个随机数。
	 */
	public int[] generateRandomArray(int expectedSum, int expectedNum, boolean ordered) {
		
		Set<Integer> set = new TreeSet<Integer>();
		/*
		 * 先将最两端的刻度加入到集合中去。 
		 */
		set.add(0);
		set.add(expectedSum);
		
		Random random = new Random();
		while (set.size() < expectedNum + 1) {
			set.add(random.nextInt(expectedSum - 1) + 1);
		}
		
		Integer[] locations = new Integer[set.size()];
		set.toArray(locations);
		
		int[] result = new int[expectedNum];
		/*
		 * 计算相邻刻度之间的长度，得到的数值就可以认为是随机数:
		 */
		for (int i = 0; i < result.length; i++) {
			result[i] = locations[i + 1] - locations[i];
		}
		
		/*
		 * 如果想让得到的随机数从小到大排列，则调用Arrays.sort
		 */
		if(ordered)
		{
			Arrays.sort(result);
		}
		return result;
	}
	
	/**
	 * 使用Collections的shuffle方法，将已有的List顺序随机打乱。
	 */
	public void shuffle(List<?> list) {
		Collections.shuffle(list);
	}
	
	/**
	 * 直接调用UUID获取随机字符串(包含'-')
	 * 
	 * 可用作数据库表的主键
	 * 
	 * 如： 53b25837-05f1-4be2-9c81-2f8bc898f6bd
	 */
	public String randomUUID1()
	{
		return UUID.randomUUID().toString();
	}
	
	/**
	 * 直接调用UUID获取随机字符串(不包含'-')
	 * 
	 * * 可用作数据库表的主键
	 * 
	 * 如： 97013848ac764487b01d0470cdde3f1a
	 */
	public String randomUUID2()
	{
		return UUID.randomUUID().toString().replaceAll("-", "");
	}
}

测试代码如下：

package my.random;

import java.util.ArrayList;
import java.util.List;

public class Main {
	public static void main(String[] args) {

		RandomUtils util = new RandomUtils();

		System.out.println("随机产生和为30的5个正整数如下：");
		printArray(util.generateRandomArray(30, 5, false));
		System.out.println();

		System.out.println("产生20个[1,100)范围的随机数:");
		int[] randomArray1 = util.gerateRandomArrayWithRange1(1, 100, 20);
		printArray(randomArray1);
		System.out.println();
		
		System.out.println("产生20个[1,100)范围的随机数:使用JDK 7  的 ThreadRandomLocal");
		int[] randomArray2 = util.gerateRandomArrayWithRange1(1, 100, 20);
		printArray(randomArray2);
		System.out.println();

		System.out.println("使用java.util.UUID产生唯一的标记(包括'-')");
		System.out.println(util.randomUUID1());
		System.out.println();

		System.out.println("使用java.util.UUID产生唯一的标记(不包括'-')");
		System.out.println(util.randomUUID2());
		System.out.println();

		System.out.println("使用Collections.shuffle打乱已有List的顺序:");
		List<Integer> intList = new ArrayList<Integer>();
		for (int i = 1; i <= 15; i++) {
			intList.add(i);
		}

		System.out.println("调用shuffle方法之前数组的内容是: ");
		printArray(intList);

		System.out.println("调用shuffle方法之后数组的内容是: ");
		util.shuffle(intList);
		printArray(intList);
		
	}

	/**
	 * 打印整形数组中的数组内容
	 */
	private static void printArray(int[] data) {
		for (int i : data) {
			System.out.print(i);
			System.out.print(" ");
		}
		System.out.println();
	}
	
	private static void printArray(List<? extends Object> list)
	{
		for(Object o :  list)
		{
			System.out.print(o + " ");
		}
		System.out.println();
	}
}

某一次运行结果如下：

随机产生和为30的5个正整数如下：
1 9 5 4 11

产生20个[1,100)范围的随机数:
59 61 4 6 54 25 36 21 29 65 32 37 80 97 98 30 26 29 38 12

产生20个[1,100)范围的随机数:使用JDK 7  的 ThreadRandomLocal
2 32 93 22 79 69 64 6 75 30 9 56 54 32 43 85 67 78 11 11

使用java.util.UUID产生唯一的标记(包括'-')
5113436d-7b79-4c4a-8bc5-a3a66d950de3

使用java.util.UUID产生唯一的标记(不包括'-')
4d505776c16243419f0e6eece940424c

使用Collections.shuffle打乱已有List的顺序:
调用shuffle方法之前数组的内容是:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
调用shuffle方法之后数组的内容是:
12 7 4 2 13 14 9 15 5 10 1 3 6 8 11