Collection类的shuffle()、sort()、binarySearch()

最新推荐文章于 2024-06-19 07:15:00 发布
最新推荐文章于 2024-06-19 07:15:00 发布
阅读量1.2k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gchichafengyun/article/details/39450041
版权
Collection类的shuffle方法

1、 RandomAccess是一个标记接口，没有任何实现方法。实现这个接口仅仅是为了表明随机访问（ random access ）比较快。比如，实现了这个接口的List，其

（注：Less than ( < =  &lt; ) and greater than ( >  &gt;  )） 
   
   

    
    

     
     for (int i=0, n=list.size(); i < n; i++)
    
    

    
    

     
               list.get(i);
访问要快于 

   
   

    
    

     
     for (Iterator i=list.iterator(); i.hasNext(); )
    
    

    
    

     
               i.next();

ArrayList和Vector实现了这个接口。

2、Collections中的shuffle()方法。

该方法有如下两个不同的重载形式。 
   
   

    
    

     
     public static void shuffle(List<?> list, Random rnd)
    
    

    
    

     
     
    
    

    
    

     
     public static void shuffle(List<?> list)

如果没有指定shuffle的Random，就创建一个默认的 Random r=new Random()： 

   
   

    
    

     
     public static void shuffle(List<?> list) {
    
    

    
    

     
             Random rnd = r;
    
    

    
    

     
             if (rnd == null)
    
    

    
    

     
                 r = rnd = new Random();
    
    

    
    

     
             shuffle(list, rnd);
    
    

    
    

     
         }
    
    

    
    

     
         private static Random r;

在这个方法中，依次从最后一个元素逆序到第二个元素，每到一个元素，随机地选取List中的一个元素与其交换。如果List元素个数比较多而且没有实现随机访问的话（对于List而言就是没有实现 RandomAccess接口 ），这个“ 随机地选取List中的一个元素 ”性能比较差，所以首先将List中的元素拷贝到数组中，因为数组支持根据下标随机访问。等shuffle完毕后将shuffle后的数据拷贝到List中： 

   
   

    
    

     
     public static void shuffle(List<?> list, Random rnd) {
    
    

    
    

     
             int size = list.size();
    
    

    
    

     
             if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
    
    

    
    

     
                 for (int i=size; i>1; i--)
    
    

    
    

     
                     swap(list, i-1, rnd.nextInt(i));
    
    

    
    

     
             } else {
    
    

    
    

     
                 Object arr[] = list.toArray();
    
    

    
    

     
     
    
    

    
    

     
                 // Shuffle array
    
    

    
    

     
                 for (int i=size; i>1; i--)
    
    

    
    

     
                     swap(arr, i-1, rnd.nextInt(i));
    
    

    
    

     
     
    
    

    
    

     
                 // Dump array back into list
    
    

    
    

     
                 ListIterator it = list.listIterator();
    
    

    
    

     
                 for (int i=0; i<arr.length; i++) {
    
    

    
    

     
                     it.next();
    
    

    
    

     
                     it.set(arr[i]);
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
         }

3、Collections中的sort()方法。
对List中的元素进行排序。 
  
  

   
   

    
    public static <T extends Comparable<? super T>> void sort(List<T> list)
   
   

   
   

    
    public static <T> void sort(List<T> list, Comparator<? super T> c)

 如果没有指定 Comparator， 则List中的元素必定要实现Comparable接口！
List必须是可修改的（支持set()），不必是可改变大小的（支持add()、remove()方法）。稳定的排序算法。
方法的实现过程是将所有元素复制到一个数组，然后再将数组中排序好的元素copy回List中。数组中排序使用的是变形的归并排序。 

   
   

    
    

     
     public static <T extends Comparable<? super T>> void sort(List<T> list) {
    
    

    
    

     
             Object[] a = list.toArray();
    
    

    
    

     
             Arrays.sort(a);
    
    

    
    

     
             ListIterator<T> i = list.listIterator();
    
    

    
    

     
             for (int j=0; j<a.length; j++) {
    
    

    
    

     
                 i.next();
    
    

    
    

     
                 i.set((T)a[j]);
    
    

    
    

     
             }
    
    

    
    

     
         }
    
    

   
   

   
   

    
    

     
     public static <T> void sort(List<T> list, Comparator<? super T> c) {
    
    

    
    

     
             Object[] a = list.toArray();
    
    

    
    

     
             Arrays.sort(a, (Comparator)c);
    
    

    
    

     
             ListIterator i = list.listIterator();
    
    

    
    

     
             for (int j=0; j<a.length; j++) {
    
    

    
    

     
                 i.next();
    
    

    
    

     
                 i.set(a[j]);
    
    

    
    

     
             }
    
    

    
    

     
         }
如果是ArrayList，为什么还要复制到数组再排序呢？应该可以直接排序啊？？？


4、Collections中的 binarySearch ()方法。    
    
   
   

    
    

     
     public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

如果List没有实现RandomAccess接口，即不支持随机访问，且List中元素数量较多，则调用   iteratorBinarySearch   方法，否则直接 调用 indexedBinarySearch方法。 indexedBinarySearch中根据下标直接取值，而 iteratorBinarySearch   根据 ListIterator取特定下标处的值： 

   
   

    
    

     
     public static <T>
    
    

    
    

     
         int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    
    

    
    

     
             if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
    
    

    
    

     
                 return Collections.indexedBinarySearch(list, key);
    
    

    
    

     
             else
    
    

    
    

     
                 return Collections.iteratorBinarySearch(list, key);
    
    

    
    

     
         }
    
    

   
   

   
   

    
    

     
     private static <T>
    
    

    
    

     
         int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key)
    
    

    
    

     
         {
    
    

    
    

     
             int low = 0;
    
    

    
    

     
             int high = list.size()-1;
    
    

    
    

     
     
    
    

    
    

     
             while (low <= high) {
    
    

    
    

     
                 int mid = (low + high) >>> 1;
    
    

    
    

     
                 Comparable<? super T> midVal = list.get(mid);
    
    

    
    

     
                 int cmp = midVal.compareTo(key);
    
    

    
    

     
     
    
    

    
    

     
                 if (cmp < 0)
    
    

    
    

     
                     low = mid + 1;
    
    

    
    

     
                 else if (cmp > 0)
    
    

    
    

     
                     high = mid - 1;
    
    

    
    

     
                 else
    
    

    
    

     
                     return mid; // key found
    
    

    
    

     
             }
    
    

    
    

     
             return -(low + 1);  // key not found
    
    

    
    

     
         }
    
    

   
   

   
   

    
    

     
     private static <T>
    
    

    
    

     
         int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key)
    
    

    
    

     
         {
    
    

    
    

     
             int low = 0;
    
    

    
    

     
             int high = list.size()-1;
    
    

    
    

     
             ListIterator<? extends Comparable<? super T>> i = list.listIterator();
    
    

    
    

     
     
    
    

    
    

     
             while (low <= high) {
    
    

    
    

     
                 int mid = (low + high) >>> 1;
    
    

    
    

     
                 Comparable<? super T> midVal = get(i, mid);      //这里变成了线性查找啊啊啊啊啊
    
    

    
    

     
                 int cmp = midVal.compareTo(key);
    
    

    
    

     
     
    
    

    
    

     
                 if (cmp < 0)
    
    

    
    

     
                     low = mid + 1;
    
    

    
    

     
                 else if (cmp > 0)
    
    

    
    

     
                     high = mid - 1;
    
    

    
    

     
                 else
    
    

    
    

     
                     return mid; // key found
    
    

    
    

     
             }
    
    

    
    

     
             return -(low + 1);  // key not found
    
    

    
    

     
         }
    
    

   
   

   
   

    
    

     
     private static <T> T get(ListIterator<? extends T> i, int index) {
    
    

    
    

     
             T obj = null;
    
    

    
    

     
             int pos = i.nextIndex();
    
    

    
    

     
             if (pos <= index) {
    
    

    
    

     
                 do {
    
    

    
    

     
                     obj = i.next();
    
    

    
    

     
                 } while (pos++ < index);
    
    

    
    

     
             } else {
    
    

    
    

     
                 do {
    
    

    
    

     
                     obj = i.previous();
    
    

    
    

     
                 } while (--pos > index);
    
    

    
    

     
             }
    
    

    
    

     
             return obj;
    
    

    
    

     
         }

gchichafengyun
关注
Java操作集合工具类Collections使用详解
08-25
2. 查询操作：Collections工具类提供了多种查询操作方法，如binarySearch()、indexOf()等。 * binarySearch(List,Object)：在List集合中查找指定元素的索引。 * indexOf(SubList,List)：返回SubList在List集合中的...
Java Collections类的shuffle和sort方法详解
分享我的点点滴滴，在成长路上与你同行！
04-04 3379
Java Collections类的shuffle和sort方法详解
关于Collections.shuffle()方法
D的博客
09-07 1万+
Java.util.Collections类下有一个静态的shuffle()方法,如下： 1）static void shuffle(List<?> list) 使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。 2）static void shuffle(List<?> list, Random rand) 使用指定的随机源对指定列表进行置换，所有置...
关于Collections.shuffle()方法的学习
热门推荐
小白
04-22 8万+
Java.util.Collections类下面有个一静态的shuffle()方法，如下： 1）static void shuffle(List list)  使用默认随机源对列表进行置换，所有置换发生的可能性都是大致相等的。 2）static void shuffle(List list, Random rand) 使用指定的随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的，假定
Java Collections.shuffle方法
allway2的博客
04-06 1万+
shuffle()是一个Java Collections类方法，其工作原理是随机置换指定列表元素。有两种不同类型的Java shuffle（）方法，可以根据其参数进行区分。这些都是： Java Collections shuffle（list）方法 Java Collections shuffle (list, random)方法 Java Collections shuffle（list）方法 shuffle（list）方法用于通过使用默认随机性对指定的列表元素进行随机重新排序来工作。 Java.
collections.shuffle用法详解
聚娃科技开发者博客
12-15 1285
通过本文，我们详细了解了的基本用法以及其在洗牌和随机选择等场景中的应用。希望这些知识能够让你在编程的世界中也能轻松驾驭集合元素的顺序。
Collections工具类_动力节点Java学院整理
08-30
Collections工具类详解 Collections工具类是Java... System.out.println("binarySearch在sort之前：，"); } ``` Collections工具类提供了大量针对Collection/Map的操作，可以帮助我们更方便地对集合进行操作和处理。
java collection framework
03-15
- `Collections.binarySearch()`: 在已排序的 List 中进行二分查找。 #### 六、使用注意事项 在使用 Java Collection Framework 时需要注意以下几点： - **线程安全性**：大多数集合类是非线程安全的，如 `...
集合工具类Collections的基本应用
11-20
例如，创建一个包含不同类型对象的列表，然后使用Collections.sort()进行排序，使用binarySearch()进行查找，最后使用replaceAll()替换特定元素。这样的实践有助于我们更好地理解和运用这些知识点。
Collections源码java-Java-Collection-:对Java的Collection框架源码阅读
05-19
比如，`sort()`方法的实现依赖于`Comparable`接口或`Comparator`接口，而`binarySearch()`则需要一个已经排序的列表。此外，源码中还隐藏了许多优化技巧和异常处理策略，这些都是提升代码质量和性能的关键。 通过对...
java实现洗牌算法——详解Collections.shuffle()
zhanggonglalala的博客
11-22 7465
洗牌题目描述 请撰写一个简单的洗牌程序，显示洗牌结果如下： 题目分析：相当于实现52个数字随机打乱顺序（没有王）。 代码实现 @SpringBootApplication public class HelloWorldMainApplication { public static void main(String[] args) { List<Integ...
Java 的Conllection.BinarySearch
PFPT的博客
03-04 294
1.Conllection.BinarySearch(List,key,c)，参数有比较器，源码如下 public static &lt;T&gt; int binarySearch(List&lt;? extends T&gt; list, T key, Comparator&lt;? super T&gt; c) { if (c==null)//判断是否有比较器 ...
Collections.shuffle()
LIUCHANGSHUO的博客
05-09 521
Java中的Collections类提供了shuffle()方法，用于对List集合中的元素进行随机排序。该方法接受一个List参数，并会随机打乱该List中的元素顺序。Java中的Collections类提供了shuffle()方法，用于对List集合中的元素进行随机排序。可以看到，在调用Collections.shuffle()方法后，List集合中的元素被随机打乱了顺序。可以看到，在调用Collections.shuffle()方法后，List集合中的元素被随机打乱了顺序。
Arrays和Collections的binarySearch
stay hungry ! stay foolish!
08-08 744
一、Arrays.binarySearch(type[] a,type key)方法 方法介绍： 第一个输入的值为相应数据类型的数组，第二个为想要查找的数值。如果查询到这个数值就会返回该数值的下标，如果没有找到，则返回插入值的负数。 在使用Arrays.binarySearch(type[] a,type key)方法前，需要对数组进行排序。 方法的返回值有几种： 1.找到的情况下：如果key在数组中，则返回搜索值的索引。 2.找不到的情况下： [1] 搜索值不是数组元素，且在数组范围内，从1.
【Java】Collections.shuffle 洗牌方法，随机重排序一组元素
Xminyang的博客
09-05 3463
Java Collections shuffle()是一个Java Collections类方法，通过随机化排列指定的列表元素来工作。根据其参数的不同，可以划分为两种不同类型的Java shuffle()： 1. Java Collections shuffle(list)方法: 使用默认的随机性对指定的列表元素进行随机重新排序。 2. Java Collections shuffle(list, random)方法: 使用指定的随机性对列表元素进行随机重排。
JAVA：Collections类的shuffle()方法
蔡先生的专栏
12-23 1万+
JAVA中Collections类的shuffle()方法的作用是将List中的内容随机打乱顺序。 import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Random; /* *Created on
【Java入坑之路】关于Collections.binarySearch查找结果不符合预期的探究
Qonent的博客
03-18 7507
目录 前言 正文 总结 前言 今天学习到辅助工具类Collections的使用（注意Collection和Collections的区别，前者是一个接口，后者是一个工具类，可以帮助我们对集合进行排序或者查找等操作），Collections中有一个二分查找方法，在使用binarySearch()时，遇到了一些问题，通过查询资料了解到问题的原因，写一篇博客记录一下。 正文 这里直接使用Ar...
Collections.binarySearch
weixin_34408717的博客
12-07 367
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中Collections.shuffle方法总结
最新发布
微赚淘客系统开发者博客
06-19 311
方法是 Java 中一个方便实用的方法，用于对集合元素进行随机排序。它可以增加程序的灵活性和趣味性，在需要随机化数据顺序的场景中有着广泛的应用。
collection工具类
08-16
9. binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分查找算法在指定列表中搜索指定元素。 10. unmodifiableCollection(Collection<? extends T> c)：返回指定集合的不可修改视图。 这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值