在网站上我们经常会看到关键字云（Word Cloud）和标签云（Tag Cloud），用于表明这个关键字或标签是经常被查阅的，而且还可以看到这些标签的动态运动，每次刷新都会有不一样的关键字或便签，让浏览者觉得这个网站的访问量非常大，短短的几分钟就有这么多的搜索量。这是怎么实现的呢？其实非常简单：先从数据库中读出标签，然后使用随机数打乱，每次都产生不同的顺序，嗯，确实能让浏览者感觉到我们的标签云顺序在变——浏览者多嘛！但是，对于乱序处理我们有哪些方法呢？

下面给出一个大家都会想到的方法：

  1.     public <T> void shuffle1(List<T> list) {
  2.         int size = list.size();
  3.         Random random = new Random();
  4.  
  5.         for(int i = 0; i < size; i++) {
  6.             // 获取随机位置
  7.             int randomPos = random.nextInt(size);
  8.  
  9.             // 当前元素与随机元素交换
  10.             T temp = list.get(i);
  11.             list.set(i, list.get(randomPos));
  12.             list.set(randomPos, temp);
  13.         }
  14.     }

很简单，实现方法也很多，但有更简单的实现方法：

  1.     public <T> void shuffle2(List<T> list) {
  2.         int size = list.size();
  3.         Random random = new Random();
  4.  
  5.         for(int i = 0; i < size; i++) {
  6.             // 获取随机位置
  7.             int randomPos = random.nextInt(size);
  8.  
  9.             // 当前元素与随机元素交换
  10.             Collections.swap(list, i, randomPos);
  11.         }
  12.     }

上面使用了Collections的swap方法，该方法会交换两个位置的元素值，不用我们自己写交换代码了，是不是更简单呢？

其实，我想说，还有更更简单的方法，如下：

  1.     public <T> void shuffle3(List<T> list) {
  2.         // 打乱顺序
  3.         Collections.shuffle(list);
  4.     }

这才是我们想要的结果，就这一句话即可打乱一个列表的顺序，不用我们费尽心思的遍历、替换元素了！

现在来测试一下，是不是都能成功实现打乱顺序呢？下面给出完整源代码：

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. import java.util.Random;
  5.  
  6. /**
  7.  * 打乱列表中数据元素的三种实现方法
  8.  */
  9. public class ShuffleTest {
  10.  
  11.     // 打乱列表实现方法1
  12.     public <T> void shuffle1(List<T> list) {
  13.         int size = list.size();
  14.         Random random = new Random();
  15.  
  16.         for(int i = 0; i < size; i++) {
  17.             // 获取随机位置
  18.             int randomPos = random.nextInt(size);
  19.  
  20.             // 当前元素与随机元素交换
  21.             T temp = list.get(i);
  22.             list.set(i, list.get(randomPos));
  23.             list.set(randomPos, temp);
  24.         }
  25.     }
  26.  
  27.     // 打乱列表实现方法2
  28.     public <T> void shuffle2(List<T> list) {
  29.         int size = list.size();
  30.         Random random = new Random();
  31.  
  32.         for(int i = 0; i < size; i++) {
  33.             // 获取随机位置
  34.             int randomPos = random.nextInt(size);
  35.  
  36.             // 当前元素与随机元素交换
  37.             Collections.swap(list, i, randomPos);
  38.         }
  39.     }
  40.  
  41.     // 打乱列表实现方法3
  42.     public <T> void shuffle3(List<T> list) {
  43.         // 打乱顺序
  44.         Collections.shuffle(list);
  45.     }
  46.  
  47.     // 打印列表
  48.     public <T> void print(List<T> list) {
  49.         for(T t : list) {
  50.             System.out.print(t + " ");
  51.         }
  52.  
  53.         System.out.println("\n");
  54.     }
  55.  
  56.     /**
  57.      * @param args
  58.      */
  59.     public static void main(String[] args) {
  60.         // TODO Auto-generated method stub
  61.  
  62.         ShuffleTest st = new ShuffleTest();
  63.         List<String> tagClouds = new ArrayList<String>(6);
  64.  
  65.         // 一般从数据库中读取，这里仅以测试为目的
  66.         tagClouds.add("计算机");
  67.         tagClouds.add("Java");
  68.         tagClouds.add("编程");
  69.         tagClouds.add("C/C++");
  70.         tagClouds.add("操作系统");
  71.         tagClouds.add("数据库");
  72.         System.out.println("原顺序：");
  73.         st.print(tagClouds);
  74.  
  75.         st.shuffle1(tagClouds);
  76.         System.out.println("打乱顺序一：");
  77.         st.print(tagClouds);
  78.  
  79.         st.shuffle2(tagClouds);
  80.         System.out.println("打乱顺序二：");
  81.         st.print(tagClouds);
  82.  
  83.         st.shuffle3(tagClouds);
  84.         System.out.println("打乱顺序三：");
  85.         st.print(tagClouds);
  86.     }
  87.  
  88. }

输出结果如下：

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAaQAAADHCAIAAADZObAiAAASsklEQVR4nO2dUZajvA4GWRcLYj2shs2wGO7D/Jc4lvRZJqS7E1c9zEmMbGSwKwZ6DtMBADAA09OXFk59rzDcWU8wAMCN1LKrN7cE9+9zRouiQQCAd6NkF4npFNzhic8G964WAQBux7ebtpIrO21GAIDfJZRdHSdllzEjyzoA+EXuWdlN8fUvKz4A+AvctrKLqrufhQGRIAC8gztXdk3ZHS2dITsAeBPX//QkLzvNnb0BAAhoXMaKxdq1lV1zKwDAO8jKzha+Ljt3E/oDgHfQeHqQlJ39aqvrwnMTsgOAd9D+/w+60DqueZWKzgDg52lcUTYfWYiYfJsAAO8G7wDAECA7ABgCZAcAQ4DsAGAILj45Tf5fC1H+N8n36zsQ/9dFBHcdE9Fm5g+VmmmLutfO3Xef8ZG5+N/F7MSIpkrXdPp1eo3v9v1vds1FnCkRLDrYdSh6f1psAjqlcuuLicEX0C07d0qIMdc1nX6XqhfRDNFCt1+72Nd5XvfL1Xvp+inqdcc7hHKeApu8Tljs3e1O3ozwKTTOYnSaM8PC1USz5V9kMrKLAsRnt2KabZmW7WrlLnpncvPgRPH669laRjEixo60aODZfO47ffCnuS67ZHlSEIZteRrSb1eAO39sTPRZz9KTR6/mdV/nulfGdSI+WgN2rQ2tLKrPbuTROn1NfbjHKmkZUVHkLM4RshsENdb1+GjGnJHNzwLHCG+mOUN0fwXr/JD2vs6TUXilKR1/u+zcf8+tVaHoeHNI2L27yYgqUTKZBqMhKoZ011mGP0v3Pbuu8mqsvCq7YrV3zud/FpimaVq28nMUr8ln2D0BmtqulnWt+B9b2Vn3HUYNunFb3W1QfLXZlmmIJHszwWtfzHXZZX4DxVi8JLvt/LjO05MEixXQY6pH8QF6Ple9q3TQnvzboh1UX8JG8Q+jP1i2uLzV5eSJyMhINyvOfnMgNXdtB9jxPPzELuyHZgfhE3njys6Ov9xg2pZ5Pb9EK7tqJp9RT8uhON7NvJoG0b/H8yxK9OjsViy7fZ2LXrfjX17ZRU5JnnERprFhVZv2wIrG3bq2d/o0uVm5e4GP5r0ru+NG2e3RYu6/jfO6P5XK+CZnX9wZ2Oypg9VZgZOejD9uvYzNnM0pJzu3/WQtoTm3ESG7ZmQzKxz3fTiDI6ekeqvQYlf8UV5y7ut83m0rJ/9e3rv/x7ZMy1xO80Z8m2jyu0cpsxbYlqdbh4WMfRXH8Wf/brtnV3UkH+lWsZa5pjA3LIoUFnOdLipmEoaPw7/HUZbUFXLYFtyWgyH1uP4sp3f5vGGe6627uS2n4yPO/KN/xZFpNl7eVyufsUR6cuNvxPYoOi/NgSHajKq45ooGTFRRtx816HY8M57hc7l4GWs3RZGXZPcLRJq+V3YeP/eHxJZynpclhxFK7+nWX0XjTdlVv0ZVR9zeib1EO/o7IxPuIntx0SzXkdF4+stDys6caE5+4logyvOaxfLtN1vWuTV/Mkt921Nmy/MjHD4dzigADAGyA4AhQHYAMATIDgCGANkBwBAgOwAYAmQHAEOA7ABgCJAdAAwBsgOAIUB2ADAEyA4AhgDZAcAQIDsAGAJkBwBDgOwAYAiQHQAMAbIDgCFAdgAwBMgOAIYA2QHAECA7ABiCvvfjqYbSr3y/pTUAgC7UO4yb70Jtvn9Tv9BTv1cU3wHAjbRXdsl3GIu60ZuMo2aTqgUAyOMv5Z4iXnhFvCs73sEOAD/PlZWdW56UnVivRQEs6wDgdbplF2koL7uocVZ8APA+HPW89TJWXNK6n5uqbS4DWRgCwGFlZ73wK7KLkrkAsgOAwz6gcCLip7GXL2Mj2eXXawAAXVz80xP7+faVXXMrAECez5DdK6ZjVQgAx5tkVxW6gsvf8nsRZAcAx2XZ6Xt2ojBayr1PdgAAh35AET0ZEMIqq7ituU0Jn17oEgCABZsAwBAgOwAYAmQHAEOA7ABgCJCdQ/TURT8y7nqcItrM/FGOrqIrNvfYtetXdnGt/XytfE9hBDj3Dtf+PkZMpMmQ3Huz5d5abiZRbl3SP7xDoQ9OufXFQ5QPE8m7RwM/fg2fcSL3dZ7X/cd21zXJe2fsLdM4U1GXZHwkxKfTKP8VVfK7btJsPKplW6haQ3Zfw0ecyG2Zlu1H9tT7e25nVDJefxXzMz/3osiMMlwpXGvZbnK/iuSv2ad5aqJdXNsd/H2qE7ktTwP1hxTz2Ou87utc79W4TsRHa8CutaGdotVnN/JoTYzmLIq8k0xb7+5CeVIHtlbUBXH0IkuKWpkcol2LHolM4KPxT6RjnLexzg+p7utsFVtpSsffLjv333NrVSgmRn4KaZ+Klt29uO5oxtg9CvvYKtFhyXQtSkOknTmYUa1kO/AFJGRXrPZOX/yzzDRN07KVn6P4kKZWq2VdK/7HVnaTcd+RmzmZiZ38qjdlEtD7sv1NtlAdwCM+XJnGM7vW+TQrorkRyMhuOz+u8/QkwWKF9VBJFO+yLdpB9SVsFP8w7oNli8sl+R/5vIyiZsWENImrrLpkF+Fmaz11QRyR7M5ykY/90Mwh2lfU32p3yWMOn8V5IrdlXs/SaGU3PZvijHpabsXxDlp2+zoXWbXjX17ZReM7GvF2Rulmm7PanYdHIAu962TObrndXUY02ibHs7aqjmc6oo+eyOTwDmPVbLKP8Lm0ZLdHi7n/Ns7r/lQq4x2szgqc6jL+uPUytummw0yJ5AzpqtXUXNRIXkmRNaKeZhJ2q0QdT8quWShSysjucvvwETzO6MNS+zqfd9tKuezls4F/bMu0zKVGGvEO2/J0a6+Qpa/KOP7c/2337M6vYgXhRrpV7NzOKywZeUFJIvKC7MpeN51eRSZ/UZo5iMTsLtzjpn8D4EMpT+Tj+rPUR/m8YZ7rrbu5LafjXcr7auUzkEhPbvyN2Jlmp4SNdANEm1EV1xdN69lpGbXcxLbgtqw72zxWth19iJI5R5lE/+rc4Jv4s2f05/6Q2FLOrrLkMNM4KTsdlmk8I7tmyeW0u2RX+UVU6ZKd7oKbQ5QAshsTzugT0UrhmsXy7Tdb7qqrk+ntXeSaKEPdQvlDYn1ky/O90NjEot8Sl659wd+EswgAQ4DsAGAIkB0ADAGyA4AhQHYAMATIDgCGANkBwBAgOwAYAmQHAEOA7ABgCJAdAAwBsgOAIUB2ADAEyA4AhgDZAcAQIDsAGAJkBwBDgOwAYAiQHQAMAbIDgCFAdgAwBMgOAIag702AqqH0y+1vaQ0AoAv1tubm2zOb7/fULwzVb+TEdwBwI+2VXeQ493XIbt3oTclRs1q1yTAAgBLfIE8RuVey52WXbBAA4EaurOzc8qTsxEIsCmC9BgCv0y07cXUZ1XXXd7YWKz4AeB+Oet56GSsuad3Pr5uOhSEAHFZ21gu/IrsomQsgOwA47AMKJyJ+Gnv5MjaSnea1ngLA0Fz80xP7+faVXXMrAECez5DdK6ZjVQgAx5tkVxW6gsvf8nsRZAcAx2XZ6Xt2ojBayl3bNXf3ACCJekARuUMIq6zituY2JaR2oUsAABZsAgBDgOwAYAiQHQAMAbIDgCFo/+ewG/8oJF8rmcY1unqUz+T1Y9J8puw+5s7sIvOsqbdZgM+injziw1O1YmvXX34kp1Ovj86nuslM8k63DUa76NJWVKuZj9gqcs7svdkywEfj/x3cK7NOzHmXZuNRLa2bKPNM2m5HejueScNG5o9M15Fs7vpe9nWe1/1NjQNcoz15IsVMRotnvPvZDfZzkv/XQuzi2u50sHtkrGTFYcm03JVhdFh0j6Kv9rT2JmbYlmnZLtUEeB+NvyKupoRbri3g1lIJmXa6ZHd5rgolJctFVpn9Vq60+XfJrnnkM+crYlv+X3Ne93WuxWZcJ+KjNWDn2vCxh2maJlQLHo3L2IzsbKFtUxBm1vJpsh3bbNRCNP+TmUeHQuc2eQqbjM7KnJvNXjjIbjIu6/yQyb7Ok1FLpSkdf5PsHrXwHESEUqtmV2ZW5Od/O61L97yuta/bSZZXWrkmO2vhMibao9BZ/uw0v/5HUyfVsq4V/0bZFau9s6l/tp2maVq28nMUD99Ee3yLmXaYKRfN+S7r6Vldze1qdxkFuDkIX+g+VmnYw6X7q/MUGV5oVmTV7OB/bIsWQX0JG8U/TPNg2eLyHM+y286P6zw9SbBYaT7Si+LhW2hropq9VYCe1bZWczrZgOjfwygmSsPdS7MkX65zEC24ByGZSbNZfcyb59pvX8tuX+d57Yi/YWW3LcUeo5Xd9GzMM+pp2RnHw3eQvTiNZpqe1ZHOOvKLlVdu7W2/SzHaGm4LGdmVWzN7iU6BpquW0tw/rM4KnKewMv54n+z2aDFXNF6Wynj4DsLrwacguWQ7zFwVFaNClWKgADszmz6qcuhVko58RXbl1yjzKNKtYk9l87AnI7fl6ZZWIQlfEXH8cdxxz+7R4L7O565Kye7lM5JHqnO5h0Y8fAOOxYTaqhJ3etjPrq0yPrJSy0gqI1NhhyqmiW3BbTmvyCi+mbBoU/cxyj/aRXlfrbz3H+nJjb+Px/VnaajyecM811t3c1tOx8MX4CwWjvRlrDsr9OyKCqsctAJukV2+VtIyr8guko7oacae4qtovCk7D6784K8T3vwS1nN9ZMuTs7Gdonf5ZrdOAdf2Isqb2nI3ue1E5ZlMml3LH4F8bgCfC6MZAIYA2QHAECA7ABgCZAcAQ4DsAGAIkB0ADAGyA4AhQHYAMATIDgCGANkBwBAgOwAYAmQHAEOA7ABgCJAdAAwBsgOAIUB2ADAEyA4AhgDZAcAQIDsAGAJkBwBDgOy6XwAEAJ8I8xzZAQxB39v5VEPpF87f0tqNIDuAEVBvUG6+g7X5llj92ln9ZlLx+lRNu9O5HQHAN9Fe2SXfoCzq2rdHR8H3WiwJsgMYAX8p9xTxwgvqXdklG/wxkB3ACFxZ2bnlSdmJ9VoU8NZlXZQ5AHwZ3bKLNJSXXdT4b634kB3ACDjqeetlrLikdT+/bqLmwhDZAYyAs2qrI35DdlEy5abk1S6yA4DDPqBwIuKnsZcvYyPZaV7raQiyAxiBi396Yj/fvrJrbr0LZAcwAp8hu1d8xGUsABxvkl1V6Aquaja56wsgOwA4LstO37MThdFS7n2ya4LsAEZAPaCIngwIYZVV3NbcpoRPo3JNru9OFwDgW2GeIzuAIWCeIzuAIWCeA8AQIDsAGIKLz0P1U4tM+WeR7+/r7TcftrgPuzO7yDxx6mo2eViuHavvGDnwd2iM8mjs2gkZTdGuafxn6f0lcI+J6LI4YiJYN5g/2r0qtwnolMqtLyYGcJlu2blTUYz1rmmcZ1/ned1faSFP1btoxmrR26/RpqYLet3xDqGcXbbJ64TF3t3u5M0IoGmMnmh4ZYajq4Nmyzm2ZVq2F+p3MRnZRQHis1vxkFeX15IRuYmvZ2sZxYgYe8ajAWDzyRwugMtcl12yPCmCim35/xSZ132da7EZ14n4aA2YXBu689nGRJ+1NWwt1xRRpJtMlFiUud1L0jKioshZHJMXZPc4/9M0TT/4QwgfhJpjelw2Y87I5ueKdX4M132d7eCtNKXjX5SdTTjqtT4O+cbdf8td2/iozWRKU+wmXSVKJtNgNFTE0GoeVed3EeD/dN+z6yqvxmhKds0BWy3rWvG3yC6p6ebWZi3XnmVMdISFCzKKSX612ZZpiCR7M7l2GJ/GQrHaO0/0v9/CaZqmZSs/R/HwTVyXXea3V8yBcDRvix5q9SVsFP8Yyw+WLS6P0X6pel1+1QfHtqmSiJPRwfqcdnVNZ1IWimEgdmE/NDtY8Sy77fy4ztOTBIvrgMfgieLhW3jjys6O+9Qg1rLb13leO+JvvWc3GXFXfaxizsJM+7Y8ik+GaWxY1aarrahxt67tnT4sblbuXgq2pRgP0cpuev49O6OeLgriePgO3ruyOy7IzuqswHkKK+OP++7Z/ePso2uE5hEQzR65ozrlZKdz0LWmWHNuIza9aHdJ2eVTDWW3R4u5/zbO6/5UKuPhO3AGZUpJZqvQYlf8cRzb8nTTpBiG/iCM44/jbtkd8bWee/T0L0EZ6e4iH+lWsZa5pjA3LIoUFnOdLipmEn6c7n2dz4FQ/gTu5ROsf2zLtMzl+W/Ewzfg31spS+oKOWwLbsvRUC7vq5V3lyM9ufH3cvYr+vcMsxUzjVefo+PTPEGiTZGh0KLeRaa/VV90YslxVfC4/iwNVT5vmOd6625uy+l4+AIuXsbaTVHkNdl5/M61RaTvd8guko5ov3nY9VfReFN2Z93o4ESFeQuLvQP0kr2oaZbryGgcf+JQtjM5ckRmbSLKk3tvZps8zl25NX+6Sn3bQ2TL8yMN4BqMJAAYAmQHAEOA7ABgCJAdAAzB/wCXDuq06MCDfAAAAABJRU5ErkJggg==" alt="" />

我们一般很少用到shuffle这个方法，那它可以用在什么地方呢？

  1. （1）可以用在程序的“伪装”上
  2. 比如我们例子中的标签云，或者是游戏中的打怪、修行、群殴时宝物的分配策略。
  3.  
  4. （2）可以用在抽奖程序中
  5. 比如年会的抽奖程序，先使用shuffle把员工顺序打乱，每个员工的中奖几率就是相等的了，然后就可以抽取第一名、第二名。
  6.  
  7. （3）可以用在安全传输方面
  8. 比如发送端发送一组数据，先随机打乱顺序，然后加密发送，接收端解密，然后自行排序，即可实现即使是相同的数据源，也会产生不同密文的效果，加强了数据的安全性。

http://www.cnblogs.com/lanxuezaipiao/p/3192980.html

  1. import lombok.extern.slf4j.Slf4j;
  2. import org.junit.Test;
  3. import org.springframework.util.StopWatch;
  4.  
  5. import java.util.ArrayList;
  6. import java.util.Collections;
  7. import java.util.List;
  8.  
  9. /**
  10.  * @author: tangcheng
  11.  * @description:
  12.  * @since: Created in 2018/08/07 11:01
  13.  */
  14. @Slf4j
  15. public class CollectShuttleTest {
  16.  
  17.     /**
  18.      * 从1000个中去掉100个，总耗时18ms
  19.      * 混淆后的数据，没有发现明显的问题
  20.      */
  21.     @Test
  22.     public void shuffleTest() {
  23.         List<Integer> total = new ArrayList<>();
  24.         for (int i = 0; i < 1000; i++) {
  25.             total.add(i);
  26.         }
  27.         StopWatch stopWatch = new StopWatch("Collections.shuffle()");
  28.         int count = 100;
  29.         List<Integer> winnerList = new ArrayList<>(100);
  30.         for (int i = 0; i < count; i++) {
  31.             stopWatch.start("time_" + i);
  32.             Collections.shuffle(total);
  33.             int index = total.size() - 1;
  34.             Integer winner = total.remove(index);
  35.             winnerList.add(winner);
  36.             log.info("taskName:{},winner:{}", i, winner);
  37.             stopWatch.stop();
  38.         }
  39.         log.info("winnerList:{},stopWatch.prettyPrint():{}", winnerList, stopWatch.prettyPrint());
  40.         /**
  41.          * winnerList:[
  42.          * 163, 905, 954, 828, 387, 217, 272, 662, 753, 160,
  43.          * 636, 629, 132, 318, 655, 388, 501, 879, 625, 515,
  44.          * 339, 897, 497, 959, 819, 654, 71, 984, 356, 256,
  45.          * 539, 330, 888, 643, 928, 10, 213, 878, 935, 206,
  46.          * 53, 875, 437, 422, 997, 464, 276, 65, 451, 732,
  47.          * 432, 154, 385, 955, 161, 719, 352, 383, 37, 853,
  48.          * 675, 696, 646, 223, 742, 807, 76, 738, 415, 516,
  49.          * 890, 656, 610, 910, 80, 7, 561, 548, 947, 390,
  50.          * 949, 236, 382, 338, 112, 240, 162, 642, 754, 571,
  51.          * 8, 802, 532, 410, 372, 462, 880, 38, 744, 360
  52.          * ],
  53.          * stopWatch.prettyPrint():StopWatch 'Collections.shuffle()': running time (millis) = 18
  54.          * -----------------------------------------
  55.          * ms     %     Task name
  56.          * -----------------------------------------
  57.          * 00007  039%  time_0
  58.          * 00000  000%  time_1
  59.          * 00000  000%  time_2
  60.          * 00001  006%  time_3
  61.          * 00000  000%  time_4
  62.          * 00000  000%  time_5
  63.          * 00000  000%  time_6
  64.          * 00000  000%  time_7
  65.          * 00000  000%  time_8
  66.          * 00000  000%  time_9
  67.          * 00000  000%  time_10
  68.          * 00000  000%  time_11
  69.          * 00001  006%  time_12
  70.          * 00000  000%  time_13
  71.          * 00000  000%  time_14
  72.          * 00000  000%  time_15
  73.          * 00000  000%  time_16
  74.          * 00000  000%  time_17
  75.          * 00000  000%  time_18
  76.          * 00000  000%  time_19
  77.          * 00000  000%  time_20
  78.          * 00000  000%  time_21
  79.          * 00000  000%  time_22
  80.          * 00000  000%  time_23
  81.          * 00001  006%  time_24
  82.          * 00000  000%  time_25
  83.          * 00000  000%  time_26
  84.          * 00000  000%  time_27
  85.          * 00001  006%  time_28
  86.          * 00000  000%  time_29
  87.          * 00001  006%  time_30
  88.          * 00000  000%  time_31
  89.          * 00000  000%  time_32
  90.          * 00000  000%  time_33
  91.          * 00000  000%  time_34
  92.          * 00000  000%  time_35
  93.          * 00000  000%  time_36
  94.          * 00000  000%  time_37
  95.          * 00000  000%  time_38
  96.          * 00000  000%  time_39
  97.          * 00000  000%  time_40
  98.          * 00001  006%  time_41
  99.          * 00000  000%  time_42
  100.          * 00000  000%  time_43
  101.          * 00000  000%  time_44
  102.          * 00000  000%  time_45
  103.          * 00000  000%  time_46
  104.          * 00000  000%  time_47
  105.          * 00000  000%  time_48
  106.          * 00000  000%  time_49
  107.          * 00000  000%  time_50
  108.          * 00001  006%  time_51
  109.          * 00000  000%  time_52
  110.          * 00000  000%  time_53
  111.          * 00000  000%  time_54
  112.          * 00000  000%  time_55
  113.          * 00000  000%  time_56
  114.          * 00000  000%  time_57
  115.          * 00000  000%  time_58
  116.          * 00000  000%  time_59
  117.          * 00000  000%  time_60
  118.          * 00000  000%  time_61
  119.          * 00000  000%  time_62
  120.          * 00001  006%  time_63
  121.          * 00000  000%  time_64
  122.          * 00000  000%  time_65
  123.          * 00001  006%  time_66
  124.          * 00000  000%  time_67
  125.          * 00000  000%  time_68
  126.          * 00000  000%  time_69
  127.          * 00000  000%  time_70
  128.          * 00000  000%  time_71
  129.          * 00000  000%  time_72
  130.          * 00000  000%  time_73
  131.          * 00000  000%  time_74
  132.          * 00000  000%  time_75
  133.          * 00000  000%  time_76
  134.          * 00001  006%  time_77
  135.          * 00000  000%  time_78
  136.          * 00000  000%  time_79
  137.          * 00000  000%  time_80
  138.          * 00000  000%  time_81
  139.          * 00000  000%  time_82
  140.          * 00000  000%  time_83
  141.          * 00000  000%  time_84
  142.          * 00000  000%  time_85
  143.          * 00000  000%  time_86
  144.          * 00000  000%  time_87
  145.          * 00000  000%  time_88
  146.          * 00000  000%  time_89
  147.          * 00000  000%  time_90
  148.          * 00000  000%  time_91
  149.          * 00001  006%  time_92
  150.          * 00000  000%  time_93
  151.          * 00000  000%  time_94
  152.          * 00000  000%  time_95
  153.          * 00000  000%  time_96
  154.          * 00000  000%  time_97
  155.          * 00000  000%  time_98
  156.          * 00000  000%  time_99
  157.          */
  158.     }
  159.  
  160. }

你会用shuffle打乱列表吗？的更多相关文章

  1. JAVA Collections.shuffle打乱列表

    在JAVA中如果想打乱LIST的顺序可以调用Collections.shuffle()或者Collections.shuffle(List<?> list, Random rnd)方法. ...

  2. Python 如何随机打乱列表(List)排序

    场景: 现在有一个list:[1,2,3,4,5,6],我需要把这个list在输出的时候,是以一种随机打乱的形式输出. 专业点的术语:将一个容器中的数据每次随机逐个遍历一遍. 注意:不是生成一个随机的 ...

  3. Python代码阅读（第10篇）：随机打乱列表元素

    本篇阅读的代码实现了随机打乱列表元素的功能,将原有列表乱序排列,并返回一个新的列表(不改变原有列表的顺序). 本篇阅读的代码片段来自于30-seconds-of-python. shuffle fro ...

  4. C#随机打乱列表List元素顺序

    C#随机打乱列表List项目顺序 以下泛型扩展方法,实现了随机打乱泛型列表List<T>的功能 public static List<t> DisorderItems<t ...

  5. python 利用numpy同时打乱列表的顺序，同时打乱数据和标签的顺序

    可用于网络训练打乱训练数据个标签,不改变对应关系 方法一: np.random.shuffle (无返回值,直接打乱原列表) state = np.random.get_state() np.rand ...

  6. shuffle 打乱一维数组

    <?php $arr = range(,); print_r($arr); echo '<br />'; shuffle($arr); print_r($arr); ?> Ar ...

  7. 编写高质量代码:改善Java程序的151个建议(第5章:数组和集合___建议75~78)

    建议75:集合中的元素必须做到compareTo和equals同步 实现了Comparable接口的元素就可以排序,compareTo方法是Comparable接口要求必须实现的,它与equals方法 ...

  8. Java编写高质量代码改善程序的151个建议

    第一章  Java开发中通用的方法和准则 建议1:不要在常量和变量中出现易混淆的字母: (i.l.1:o.0等). 建议2:莫让常量蜕变成变量: (代码运行工程中不要改变常量值). 建议3:三元操作符 ...

  9. Python_Mix*random模块,time模块,sys模块,os模块

    random模块 作用: 生成随机数(整数,小数,从列表中随机抽值,打乱列表顺序) 常用函数: random.random( )生成随机小数 random.uniform( )取一个范围之间的小数 r ...

随机推荐

  1. memcached的安装和linux下memcached服务自启动的配置

    关于memcached在windows和linux环境的安装,以及在Linux系统系memcached服务自启动的配置,可以参考我在csdn上下的博客, windows和linux环境下memcach ...

  2. 一.oracle的SQL中group by使用的情况(与聚合函数的关系)

    SELECT r.industry_1,r.industry_2,r.agent_id,r.agent_name,COUNT(DISTINCT r.customer_name_a)数据总量,COUNT ...

  3. 让乌龟在提交cocos2d-x版本时自动去掉不需要的东东

    引擎版本:2.1.4 ide:vs2012 一般协作开发情况下,有意思无意将bin.obj等一些目录添加到版本管理中是很烦人的事儿,在VS中不断地编译程序集和提交将带来版本暴增问题.如果你用的是乌龟S ...

  4. MySQL RR隔离 读一致性

    MySQL RR 模式下 事务隔离问题: Session 1: mysql> select * from test; +------+------+ | id | name | +------+ ...

  5. Android GUI Building Blocks

    说明:此笔记为“Android开发”学习视频的笔记,链接如下:http://open.163.com/movie/2010/1/8/D/M79HE97C3_M79HEQJ8D.html 一, Acti ...

  6. 如何将你牛逼的iOS代码分享到CocoaPod（转）

    为了让读者一目了然,现在就从新建工程到最后提交podspec,简单粗暴的讲一通.Cocoapods不用解释太多,一句话...它是目前iOS开发中最广为使用的第三方库依赖管理工具. 下面开始讲创建pod ...

  7. C#性能优化实践【转】

    性能主要指两个方面:内存消耗和执行速度.性能优化简而言之,就是在不影响系统运行正确性的前提下,使之运行地更快,完成特定功能所需的时间更短. 本文以.NET平台下的控件产品MultiRow为例,描述C# ...

  8. Floodlight中 处理packetin消息的顺序（1）

    当Controller和SW建立连接之后,就能够处理来自SW的各种OF msg.当接收到 packetin 消息之后,会将其分发给各个监听了这个OFMessage的listeners,所以假设我们要设 ...

  9. 怎样解决xcode里开发cocos2dx改动lua脚本后不刷新的问题

    用xcode来开发cocos2dx,结果发现一个非常纠结的问题,假设我一旦改动了一个Lua文件,我必须clean之后再build,否则改动的Lua文件不会体现出来.这是一个非常令纠结的结果,特别是我要 ...

  10. SVN导出增量包的方法

    此方法是在svn1.7版本基础上进行的操作,其他版本没有验证 第一步.点击右键,选择“TortoiseSVN–> Show log”. 进入日志页面,如下图所示: 第二步.选择版本区间,右键选择 ...