blocks|key|497960|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|497961|public+static+List<String>+pickNRandom(List<String>+lst,+int+n)+{
++++List<String>+copy+=+new+ArrayList<String>(lst);
++++Collections.shuffle(copy);
++++return+n+>+copy.size()+?+copy.subList(0,+copy.size())+:+copy.subList(0,+n);
}|code-block|syntax|javascript|497962|我假设在输入列表中没有重复的元素，而且我采取了预防措施，为了保持原始列表不受干扰，我会混洗一份副本。像这样使用它：|497963|List<String>+randomPicks+=+pickNRandom(teamList,+3);|497964|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Try this:
<pre><code>public static List&lt;String&gt; pickNRandom(List&lt;String&gt; lst, int n) {
 List&lt;String&gt; copy = new ArrayList&lt;String&gt;(lst);
 Collections.shuffle(copy);
 return n &gt; copy.size() ? copy.subList(0, copy.size()) : copy.subList(0, n);
}
</code></pre>
I'm assuming that there are no repeated elements in the input list, also I take the precaution of shuffling a copy for leaving the original list undisturbed. Use it like this:
<pre><code>List&lt;String&gt; randomPicks = pickNRandom(teamList, 3);
</code></pre>

blocks|key|497896|text|创建一组int，并在循环中将介于0和list长度减1之间的随机数放入其中，而集合的大小不等于期望的随机元素数。浏览集合，并选择集合中的数字所指示的列表元素。这种方式可以保持你的原始列表不变。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|497897|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Create a set of ints, and put random numbers between 0 and list's length minus one into it in a loop, while the size of the set is not equal the desired number of random elements. Go through the set, and pick list elements as indicated by the numbers in the set. This way would keep your original list intact.

blocks|key|497931|text|shuffle方法是最常用的方法:在此之后，前K个元素就是您所需要的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|497932|如果K比列表的长度小得多，你可能想要更快。在这种情况下，遍历列表，随机地将当前元素与其自身或其后的任何元素进行交换。在第K个元素之后，停止并返回K前缀:它已经完全混洗过了，您不需要关心列表的其余部分。|497933|(显然，您希望在这里使用ArrayList+)|497934|entityMap^0|0|7|0|0|C|9|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

The <code>shuffle</code> approach is the most idiomatic: after that, first K elements are exactly what you need. 

If K is much less than the length of the list, you may want to be faster. In this case, iterate through the list, randomly exchanging the current element with itself or any of the elements after it. After the K-th element, stop and return the K-prefix: it will be already perfectly shuffled, and you don't need to care about the rest of the list.

(obviously, you'd like to use <code>ArrayList</code> here)

blocks|key|713568|text|您也可以使用reservoir+sampling。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|713569|它的优点是，你不需要事先知道源列表的大小(例如，如果你得到的是Iterable而不是List)。而且，即使源列表不是随机访问的，它也是有效的，就像示例中的LinkedList一样。|style|CODE|713570|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Reservoir_sampling^0|6|I|0|0|V|8|16|4|25|A|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]|$A|W|B|X|F|G]|$A|Y|B|Z|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You can also use <a href="http://en.wikipedia.org/wiki/Reservoir_sampling" rel="nofollow">reservoir sampling</a>.

It has the advantage that you do not need to know the size of the source list in advance (e.g. if you are given an <code>Iterable</code> instead of a <code>List</code>.) Also it is efficient even when the source list is not random-access, like the <code>LinkedList</code> in your example.

blocks|key|713616|text|以下是一种使用Java+streams完成此操作的方法，而无需创建原始列表的副本或对其进行混洗：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713617|public+static+List<String>+pickRandom(List<String>+list,+int+n)+{
++++if+(n+>+list.size())+{
++++++++throw+new+IllegalArgumentException("not+enough+elements");
++++}
++++Random+random+=+new+Random();
++++return+IntStream
++++++++++++.generate(()+->+random.nextInt(list.size()))
++++++++++++.distinct()
++++++++++++.limit(n)
++++++++++++.mapToObj(list::get)
++++++++++++.collect(Collectors.toList());
}|code-block|syntax|javascript|713618|注意:对于大型列表，当n太接近列表大小时，效率会变得很低。|offset|length|style|CODE|713619|entityMap^0|0|0|B|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is a way of doing it using Java streams, without having to create a copy of the original list or shuffling it:

<pre><code>public static List&lt;String&gt; pickRandom(List&lt;String&gt; list, int n) {
 if (n &gt; list.size()) {
 throw new IllegalArgumentException("not enough elements");
 }
 Random random = new Random();
 return IntStream
 .generate(() -&gt; random.nextInt(list.size()))
 .distinct()
 .limit(n)
 .mapToObj(list::get)
 .collect(Collectors.toList());
}
</code></pre>

Note: It can become inefficient when <code>n</code> is too close to the list size for huge lists.

blocks|key|713307|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713308|Collections.shuffle(teamList);|code-block|syntax|javascript|713309|要随机化列表，然后通过teamList.remove(0);从列表中一次删除一个团队|offset|length|style|CODE|713310|例如：|713311|++List<String>+teamList+=+new+LinkedList<String>();
++teamList.add("team1");
++teamList.add("team2");
++teamList.add("team3");
++teamList.add("team4");
++teamList.add("team5");
++teamList.add("team6");

++java.util.Collections.shuffle(teamList);

++String[]+chosen3+=+new+String[3];
++for+(int+i+=+0;+i+<+chosen3.length+&&+teamList.size()+>+0;+i%2B%2B)+{
+++++chosen3[i]+=+teamList.remove(0);
++}|713312|entityMap^0|0|0|B|J|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Use 

<pre><code>Collections.shuffle(teamList);
</code></pre>

to randomize the list, then remove teams one at a time from the list via <code>teamList.remove(0);</code>

For example:

<pre><code> List&lt;String&gt; teamList = new LinkedList&lt;String&gt;();
 teamList.add("team1");
 teamList.add("team2");
 teamList.add("team3");
 teamList.add("team4");
 teamList.add("team5");
 teamList.add("team6");

 java.util.Collections.shuffle(teamList);

 String[] chosen3 = new String[3];
 for (int i = 0; i &lt; chosen3.length &amp;&amp; teamList.size() &gt; 0; i++) {
 chosen3[i] = teamList.remove(0);
 }
</code></pre>

blocks|key|713509|text|除了洗牌之外，所有的好主意都是昂贵的。更有效的方法(IMO)是执行计数控制循环，并在0和n之间随机选取一个int；其中n最初等于列表的长度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713510|在循环的每次迭代中，您将所选的项与列表中n-1处的项交换，并将n减1。这样，您就避免了两次选择同一个元素，也不必保留一个单独的选定项列表。|713511|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

All good ideas but shuffling is expensive. The more efficient method (IMO) would be doing a count controlled loop and picking a random int between 0 and n; where n initially is equal to the length of your list.

In each iteration of the loop you swap the selected item with the item at n-1 on the list and decrement n by one. This way you avoid picking the same element two times and don't have to keep a separate list of selected items.

blocks|key|498155|text|int[]+getRandoms(int[]+ranges,+int+n,+int[]+excepts)+{
++++int+min+=+ranges[0];
++++int+max+=+ranges[1];

++++int[]+results+=+new+int[n];
++++for+(int+i+=+0;+i+<+n;+i%2B%2B)+{
++++++++int+randomValue+=+new+Random().nextInt(max+-+min+%2B+1)+%2B+min;
++++++++if+(ArrayUtils.contains(results,+randomValue)+%7C%7C+ArrayUtils.contains(excepts,+randomValue))+{
++++++++++++i--;
++++++++}+else+{
++++++++++++results[i]+=+randomValue;
++++++++}
++++}
++++return+results;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|498156|util类|unstyled|498157|public+static+class+ArrayUtils+{

++++public+static+boolean+contains(int[]+array,+int+elem)+{
++++++++return+getArrayIndex(array,+elem)+!=+-1;
++++}

++++/**+Return+the+index+of+{@code+needle}+in+the+{@code+array},+or+else+{@code+-1}+*/
++++public+static+int+getArrayIndex(int[]+array,+int+needle)+{
++++++++if+(array+==+null)+{
++++++++++++return+-1;
++++++++}
++++++++for+(int+i+=+0;+i+<+array.length;+%2B%2Bi)+{
++++++++++++if+(array[i]+==+needle)+{
++++++++++++++++return+i;
++++++++++++}
++++++++}
++++++++return+-1;
++++}
}|498158|使用|498159|int[]+randomPositions+=+getRandoms(new+int[]{0,list.size()-1},+3,+new+int[]{0,1});|498160|它将在你的列表中随机选择3个项目，除了项目0和项目1|498161|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>int[] getRandoms(int[] ranges, int n, int[] excepts) {
 int min = ranges[0];
 int max = ranges[1];

 int[] results = new int[n];
 for (int i = 0; i &lt; n; i++) {
 int randomValue = new Random().nextInt(max - min + 1) + min;
 if (ArrayUtils.contains(results, randomValue) || ArrayUtils.contains(excepts, randomValue)) {
 i--;
 } else {
 results[i] = randomValue;
 }
 }
 return results;
}
</code></pre>

util class

<pre><code>public static class ArrayUtils {

 public static boolean contains(int[] array, int elem) {
 return getArrayIndex(array, elem) != -1;
 }

 /** Return the index of {@code needle} in the {@code array}, or else {@code -1} */
 public static int getArrayIndex(int[] array, int needle) {
 if (array == null) {
 return -1;
 }
 for (int i = 0; i &lt; array.length; ++i) {
 if (array[i] == needle) {
 return i;
 }
 }
 return -1;
 }
}
</code></pre>

using

<pre><code>int[] randomPositions = getRandoms(new int[]{0,list.size()-1}, 3, new int[]{0,1});
</code></pre>

it will random 3 items in your list except item 0 and item 1

So say I have

<pre><code>List&lt;String&gt; teamList = new LinkedList&lt;String&gt;()
teamList.add("team1");
teamList.add("team2");
teamList.add("team3");
teamList.add("team4");
teamList.add("team5");
teamList.add("team6");
</code></pre>

Is there a simple way of picking... say 3 out the 6 elements in this list in a randomized way without picking the same element twice (or more times)?

Pick multiple random elements from a list in Java

所以说我有List<String> teamList = new LinkedList<String>()teamList.add("team1");teamList.add("team2");teamList.add("team3");teamList.add("team4");teamList.add("team5");teamList.add("team6");有没有简单的方法来挑选..。假

问在Java中从列表中选取多个随机元素
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中从列表中选取多个随机元素EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中从列表中选取多个随机元素
EN