不重复地随机获取List或者数组元素

摘要: 需要从结果集（一般是list或者数组）中随机抽取若干条不重复的记录，这里的不重复是结果集下标的不重复，而不是针对元素本身的

为了方便，我就以list为例：

算法思路

第一种方法的思路是：用set存储已经取过的下标，每次循环取的时候，判断是否已经取过
如果已经取过就跳过本次循环，一直到取num为止

这个方法不推荐使用，可能会发生死循环

如果每一次的数据值都是同一个，那么就是死循环了，虽然概论极其低，但是不代表没有

public static List getListUnique1(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Set<Integer> gotIndexs = new HashSet<>(num); // 以获取的下标
Random random = new Random();
while (gotIndexs.size() < num) {
int i = random.nextInt(_sources.size());

// 已经获取过了，跳过本次循环
if (gotIndexs.contains(i)) continue;

// 如果没有获取过，则放入数据
targetList.add(_sources.get(i));
gotIndexs.add(i);

}
return targetList;
}

第二种方法思路是：每一次循环取完数据后，从目标list中移除本次取的数据，list的大小也变小了，下一次循环产生的随机数最大值也是list的size，所以不会发生越界问题。

public static List getListUnique2(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Random random = new Random();
for (int k = 0; k < num; k++) {
int i = random.nextInt(_sources.size());
targetList.add(_sources.get(i));
// 取完后，从目标list内移除该数据
_sources.remove(i);
}
return targetList;
}

第三中方法思路：每一次循环取完数据后，把list size - k -1 的元素 放到本次取到的index位置，下次循环的随机数最大值为list size - k

public static List getListUnique3(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Random random = new Random();
for (int k = 0; k < num; k++) {
int i = random.nextInt(_sources.size() - k);
Object tmp = _sources.get(i);
targetList.add(tmp);
// 取完后，把list size - k 的元素 放到本次取到的index位置
_sources.set(i, _sources.get(_sources.size() - k - 1));

}
return targetList;
}

分析

第一种方法，不推荐使用，这里就不说了

如果list的实现为ArrayList，那么第三种方法会比第二种好，因为在list移除的时候，实际上发生的数组的复制，有兴趣的可以了解ArrayList的实现。

如果list的实现为LinkedList，那么第三种方法和第二种方法没有太多的差别

上面的算法实现还可以优化，例如，不用复制一份原数据，直接使用原数据的下标形成新的List，然后对下标进行随机取，取完后在根据下标去原list中取对应的数据。

上面只给了List的实现，那数组的实现呢？方法有两种：

最简单的是把数组转换为ArrayList，然后就一样了

根据上面的思路，用数组实现。

各位，如果你有什么更好的想法，也欢迎评论

附源码

/**
* 获取不重复下标的元素
*/
public class UniqueCollectionIndex {

public static void main(String[] args) {

int num = 6;

List list1 = new ArrayList();
// 放入A-Z做测试
for (int i = 65; i < 91; i++) {
list1.add((char) i);
}

System.out.println(getListUnique1(list1, num));
System.out.println(getListUnique2(list1, num));
System.out.println(getListUnique3(list1, num));

}

//***** list *******

/**
* <p style="color:red">不推荐使用，可能会发生死循环</p>
* 用set存储已经取过的下标，每次循环取的时候，判断是否已经取过
* 如果已经取过就跳过本次循环，一直到取num为止
*
* @param sources 目标list
* @param num     获取元素的数量
* @return 获取的list
*/
public static List getListUnique1(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Set<Integer> gotIndexs = new HashSet<>(num); // 以获取的下标
Random random = new Random();
while (gotIndexs.size() < num) {
int i = random.nextInt(_sources.size());

// 已经获取过了，跳过本次循环
if (gotIndexs.contains(i)) continue;

// 如果没有获取过，则放入数据
targetList.add(_sources.get(i));
gotIndexs.add(i);

}
return targetList;
}
/**
* 每一次循环取完数据后，从目标list中移除本次取的数据
*
* @param sources 目标list
* @param num     获取元素的数量
* @return 获取的list
*/
public static List getListUnique2(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Random random = new Random();
for (int k = 0; k < num; k++) {
int i = random.nextInt(_sources.size());
targetList.add(_sources.get(i));
// 取完后，从目标list内移除该数据
_sources.remove(i);
}
return targetList;
}
/**
* 每一次循环取完数据后，把list size - k -1 的元素 放到本次取到的index位置，
* 下次循环的随机数最大值为list size - k
*
* @param sources 目标list
* @param num     获取元素的数量
* @return 获取的list
*/
public static List getListUnique3(List sources, int num) {

if (sources.size() <= num) {
return sources;
}

// 复制一份，以免对原数据造成影响
List _sources = new ArrayList(sources);

List targetList = new ArrayList(num);
Random random = new Random();
for (int k = 0; k < num; k++) {
int i = random.nextInt(_sources.size() - k);
Object tmp = _sources.get(i);
targetList.add(tmp);
// 取完后，把list size - k 的元素 放到本次取到的index位置
_sources.set(i, _sources.get(_sources.size() - k - 1));

}
return targetList;
}
}