java源码分析:Arrays.sort

  1   2
  3 仔细分析java的Arrays.sort(version 1.71, 04/21/06)后发现,java对primitive(int,float等原型数据)数组采用快速排序,对Object对象数组采用归并排序。
  4   对这一区别,sun在<<The Java Tutorial>>中做出的解释是:
  5   The sort operation uses a slightly optimized merge sort algorithm that is fast and stable:
  6    * Fast: It is guaranteed to run in n log(n) time and runs substantially faster on nearly sorted lists. Empirical tests showed it to be as fast as a highly optimized quicksort. A quicksort is generally considered to be faster than a merge sort but isn‘t stable and doesn‘t guarantee n log(n) performance.
  7   * Stable: It doesn‘t reorder equal elements. This is important if you sort the same list repeatedly on different attributes. If a user of a mail program sorts the inbox by mailing date and then sorts it by sender, the user naturally expects that the now-contiguous list of messages from a given sender will (still) be sorted by mailing date. This is guaranteed only if the second sort was stable.
  8   也就是说,优化的归并排序既快速(nlog(n))又稳定。
  9   对于对象的排序,稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。
 10   而快速排序是不稳定的,而且最坏情况下的时间复杂度是O(n^2)。
 11   另外,对象数组中保存的只是对象的引用,这样多次移位并不会造成额外的开销,但是,对象数组对比较次数一般比较敏感,有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好,这也是选择它作为对象排序的一个重要原因之一。
 12   排序优化:实现中快排和归并都采用递归方式,而在递归的底层,也就是待排序的数组长度小于7时, 直接使用冒泡排序,而不再递归下去。
 13   分析:长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次,最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销,其时间效率在n较小时劣势就凸显了,因此这里采用了冒泡排序,这也是对快速排序极重要的优化。
 14   /*快速排序*/
 15   private static void sort1(int x[], int off, int len) {
 16   // Insertion sort on smallest arrays
 17     if (len < 7) {
 18       for (int i=off; i<len+off; i++)
 19       for (int j=i; j>off && x[j-1]>x[j]; j--)
 20           swap(x, j, j-1);
 21           return;
 22     }
 23   // Choose a partition element, v
 24   int m = off + (len >> 1); // Small arrays, middle element
 25   if (len > 7) {
 26   int l = off;
 27   int n = off + len - 1;
 28   if (len > 40) { // Big arrays, pseudomedian of 9
 29   int s = len/8;
 30   l = med3(x, l, l+s, l+2*s);//取后三个参数中的中间值
 31   m = med3(x, m-s, m, m+s);
 32   n = med3(x, n-2*s, n-s, n);
 33   }
 34   m = med3(x, l, m, n); // Mid-size, med of 3
 35   }
 36   int v = x[m];
 37   // Establish Invariant: v* (<v)* (>v)* v*
 38   int a = off, b = a, c = off + len - 1, d = c;
 39   while(true) {
 40   while (b <= c && x[b] <= v) {
 41   if (x[b] == v)
 42   swap(x, a++, b);
 43   b++;
 44   }
 45   while (c >= b && x[c] >= v) {
 46   if (x[c] == v)
 47   swap(x, c, d--);
 48   c--;
 49   }
 50   if (b > c)
 51   break;
 52   swap(x, b++, c--);
 53   }
 54   // Swap partition elements back to middle
 55   int s, n = off + len;
 56   s = Math.min(a-off, b-a ); vecswap(x, off, b-s, s);
 57   s = Math.min(d-c, n-d-1); vecswap(x, b, n-s, s);
 58   // Recursively sort non-partition-elements
 59   if ((s = b-a) > 1)
 60   sort1(x, off, s);
 61   if ((s = d-c) > 1)
 62   sort1(x, n-s, s);
 63   }
 64   /*归并排序*/
 65   private static void mergeSort(Object[] src,
 66   Object[] dest,
 67   int low,
 68   int high,
 69   int off) {
 70   int length = high - low;
 71   // Insertion sort on smallest arrays
 72   if (length < INSERTIONSORT_THRESHOLD) {
 73   for (int i=low; i<high; i++)
 74   for (int j=i; j>low &&
 75   ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
 76   swap(dest, j, j-1);
 77   return;
 78   }
 79   // Recursively sort halves of dest into src
 80   int destLow = low;
 81   int destHigh = high;
 82   low += off;
 83   high += off;
 84   int mid = (low + high) >>> 1;
 85   mergeSort(dest, src, low, mid, -off);
 86   mergeSort(dest, src, mid, high, -off);
 87   // If list is already sorted, just copy from src to dest. This is an
 88   // optimization that results in faster sorts for nearly ordered lists.
 89   if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
 90   System.arraycopy(src, low, dest, destLow, length);
 91   return;
 92   }
 93   // Merge sorted halves (now in src) into dest
 94   for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
 95   if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
 96   dest[i] = src[p++];
 97   else
 98   dest[i] = src[q++];
 99   }
100   }
时间: 2024-10-18 00:51:42

java源码分析:Arrays.sort的相关文章

《Java源码分析》:Vector

<Java源码分析>:Vector 虽然,Vector集合在我们的编程中,使用的比较少,至少我使用的比较少,一般情况下,我都是倾向于使用List来存储一些同类型的元素. 其实,Vector的内部实现和ArrayList的内部实现基本一致,内部都是借助于数组来实现的.下面就一起来分析下. HashMap类的源码分析,博客在这里:http://blog.csdn.net/u010412719/article/details/51980632 Hashtable类的源码分析,博客在这里:http:/

《Java源码分析》:线程池 ThreadPoolExecutor

<Java源码分析>:线程池 ThreadPoolExecutor ThreadPoolExecutor是ExecutorService的一张实现,但是是间接实现. ThreadPoolExecutor是继承AbstractExecutorService.而AbstractExecutorService实现了ExecutorService接口. 在介绍细节的之前,先介绍下ThreadPoolExecutor的结构 1.线程池需要支持多个线程并发执行,因此有一个线程集合Collection来执行

《Java源码分析》:Java NIO 之 Buffer

<Java源码分析>:Java NIO 之 Buffer 在上篇博文中,我们介绍了Java NIO 中Channel 和Buffer的基本使用方法,这篇博文将从源码的角度来看下Buffer的内部实现. 在Java API文档中,对Buffer的说明摘入如下: Buffer:是一个用于特定基本数据类型的容器.这里的特定基本数据类型指的是:除boolean类型的其他基本上数据类型. 缓冲区是特定基本数据类型元素的线性有限序列.除内容外,缓冲区饿基本属性还包括三个重要的属性,如下: 1.capaci

《Java源码分析》:HashMap

<Java源码分析>:HashMap 看过很多次HashMap的源码了,但是,每次都没有做记录,因此,每次记忆都不太深,今天在看别人博客时提到Hashtable是线程安全的,Hashtable中的方法都用了synchronized进行了同步,于是就看了下Hashtable的源码,在看的过程中,写了篇博客,现在2016年7月20日22:03:53,还在教研室,感觉回寝室还早,因此,决定再看下HashMap的源码,也随便以写博客的形式做点笔记. 还是很看其他类的源码一样,先看构造函数,然后看一些比

java 集合类源码分析--arrays

本文介绍一下java集合相关类arryas类的内容 .Arrays.sort()数组排序 Java Arrays中提供了对所有类型的排序.其中主要分为Primitive(8种基本类型)和Object两大类. 基本类型:采用调优的快速排序: 对象类型:采用改进的归并排序. 1.对于基本类型源码分析如下(以int[]为例): public static void sort(int[] a, int fromIndex, int toIndex) { //进行数组的界限检查 rangeCheck(a.

Java源码分析——String的设计

Tip:笔者马上毕业了,准备开始Java的进阶学习计划.于是打算先从String类的源码分析入手,作为后面学习的案例.这篇文章寄托着今后进阶系列产出的愿望,希望能坚持下去,不忘初心,让自己保持那份对技术的热爱. 因为学习分析源码,所以借鉴了HollisChuang成神之路的大部分内容,并在此基础上对源码进行了学习,在此感谢. 问题的引入 关于String字符串,对于Java开发者而言,这无疑是一个非常熟悉的类.也正是因为经常使用,其内部代码的设计才值得被深究.所谓知其然,更得知其所以然. 举个例

java源码分析之HashSet

http://blog.csdn.net/jzhf2012/article/details/8540696 Java容器类的用途是"保存对象",分为两类:Map--存储"键值对"组成的对象:Collection--存储独立元素.Collection又可以分为List和Set两大块.List保持元素的顺序,而Set不能有重复的元素. 本文分析Set中最常用的HashSet类,并简单介绍和对比LinkedHashSet. 首先对Set接口进行简要的说明. 存入Set的每

java源码分析之集合框架HashMap 10

HashMap HashMap 是一个散列表,它存储的内容是键值对(key-value)映射. HashMap 继承于AbstractMap,实现了Map.Cloneable.java.io.Serializable接口. HashMap 的实现不是同步的,这意味着它不是线程安全的.它的key.value都可以为null.此外,HashMap中的映射不是有序的. HashMap 的实例有两个参数影响其性能:"初始容量" 和 "加载因子".容量 是哈希表中桶的数量,初

Java源码分析系列之ArrayList读后感

1.前言 在平时的开发中,Java集合一直是比较常用的.以前,对集合的掌握并不深入,仅简单的使用增删改查的相关方法.这个星期,抽时间反复的读了几遍ArrayList的源码,有了一些收获,写出来给自己,也希望对大家有帮助. 2.走进ArrayList 看一下ArrayList的声明和属性 声明: public class ArrayList<E> extends AbstractList<E>         implements List<E>, RandomAcces