一、Arrays.sort()数组排序
Java Arrays中提供了对所有类型的排序。其中主要分为Primitive(8种基本类型)和Object两大类。
基本类型:采用调优的快速排序;
对象类型:采用改进的归并排序。
1、对于基本类型源码分析如下(以int[]为例):
Java对Primitive(int,float等原型数据)数组采用快速排序,对Object对象数组采用归并排序。对这一区别,sun在<<The Java Tutorial>>中做出的解释如下:
The sort operation uses a slightly optimized merge sort algorithm that is fast and stable:
* 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.
* 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.
也就是说,优化的归并排序既快速(nlog(n))又稳定。
对于对象的排序,稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。
而快速排序是不稳定的,而且最坏情况下的时间复杂度是O(n^2)。
另外,对象数组中保存的只是对象的引用,这样多次移位并不会造成额外的开销,但是,对象数组对比较次数一般比较敏感,有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好,这也是选择它作为对象排序的一个重要原因之一。
排序优化:实现中快排和归并都采用递归方式,而在递归的底层,也就是待排序的数组长度小于7时,直接使用冒泡排序,而不再递归下去。
分析:长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次,最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销,其时间效率在n较小时劣势就凸显了,因此这里采用了冒泡排序,这也是对快速排序极重要的优化。
源码中的快速排序,主要做了以下几个方面的优化:
1)当待排序的数组中的元素个数较少时,源码中的阀值为7,采用的是插入排序。尽管插入排序的时间复杂度为0(n^2),但是当数组元素较少时,插入排序优于快速排序,因为这时快速排序的递归操作影响性能。
2)较好的选择了划分元(基准元素)。能够将数组分成大致两个相等的部分,避免出现最坏的情况。例如当数组有序的的情况下,选择第一个元素作为划分元,将使得算法的时间复杂度达到O(n^2).
源码中选择划分元的方法:
当数组大小为 size=7 时 ,取数组中间元素作为划分元。int n=m>>1;(此方法值得借鉴)
当数组大小 7<size<=40时,取首、中、末三个元素中间大小的元素作为划分元。
当数组大小 size>40 时 ,从待排数组中较均匀的选择9个元素,选出一个伪中数做为划分元。
3)根据划分元 v ,形成不变式 v* (<v)* (>v)* v*
普通的快速排序算法,经过一次划分后,将划分元排到素组较中间的位置,左边的元素小于划分元,右边的元素大于划分元,而没有将与划分元相等的元素放在其附近,这一点,在Arrays.sort()中得到了较大的优化。
举例:15、93、15、41、6、15、22、7、15、20
因 7<size<=40,所以在15、6、和20 中选择v = 15 作为划分元。
经过一次换分后: 15、15、7、6、41、20、22、93、15、15. 与划分元相等的元素都移到了素组的两边。
接下来将与划分元相等的元素移到数组中间来,形成:7、6、15、15、15、15、41、20、22、93.
最后递归对两个区间进行排序[7、6]和[41、20、22、93].
部分源代码(一)如下:
1 package com.util;
2
3publicclass ArraysPrimitive {
4 private ArraysPrimitive(){}
5
6 /**
7 * 对指定的 int 型数组按数字升序进行排序。
8 */
9 publicstaticvoid sort(int[] a) {
10 sort1(a, 0, a.length);
11 }
12
13 /**
14 * 对指定 int 型数组的指定范围按数字升序进行排序。
15 */
16 publicstaticvoid sort(int[] a, int fromIndex, int toIndex) {
17 rangeCheck(a.length, fromIndex,toIndex);
18 sort1(a, fromIndex, toIndex -fromIndex);
19 }
20
21 privatestaticvoid sort1(int x[], int off, int len) {
22 /*
23 * 当待排序的数组中的元素个数小于 7 时,采用插入排序。
24 *
25 * 尽管插入排序的时间复杂度为O(n^2),但是当数组元素较少时,插入排序优于快速排序,因为这时快速排序的递归操作影响性能。
26 */
27 if (len < 7) {
28 for (int i = off; i <len + off; i++)
29 for (int j = i; j > off&& x[j - 1] > x[j]; j--)
30 swap(x, j, j - 1);
31 return;
32 }
33 /*
34 * 当待排序的数组中的元素个数大于或等于7 时,采用快速排序。
35 *
36 * Choose a partition element, v
37 * 选取一个划分元,V
38 *
39 * 较好的选择了划分元(基准元素)。能够将数组分成大致两个相等的部分,避免出现最坏的情况。例如当数组有序的的情况下,
40 * 选择第一个元素作为划分元,将使得算法的时间复杂度达到O(n^2).
41 */
42 // 当数组大小为size=7时,取数组中间元素作为划分元。
43 int m = off + (len>> 1);
44 // 当数组大小 7<size<=40时,取首、中、末三个元素中间大小的元素作为划分元。
45 if (len > 7) {
46 int l = off;
47 int n = off + len - 1;
48 /*
49 * 当数组大小 size>40 时,从待排数组中较均匀的选择9个元素,
50 * 选出一个伪中数做为划分元。
51 */
52 if (len > 40) {
53 int s = len / 8;
54 l = med3(x, l, l + s, l + 2 * s);
55 m = med3(x, m - s, m, m + s);
56 n = med3(x, n - 2 * s, n - s, n);
57 }
58 // 取出中间大小的元素的位置。
59 m = med3(x, l, m, n); // Mid-size, medof 3
60 }
61
62 //得到划分元V
63 int v = x[m];
64
65 // EstablishInvariant: v* (<v)* (>v)* v*
66 int a = off, b = a, c= off + len - 1, d = c;
67 while (true) {
68 while (b <= c&& x[b] <= v) {
69 if (x[b] == v)
70 swap(x, a++, b);
71 b++;
72 }
73 while (c >= b&& x[c] >= v) {
74 if (x[c] == v)
75 swap(x, c, d--);
76 c--;
77 }
78 if (b > c)
79 break;
80 swap(x, b++, c--);
81 }
82 // Swap partitionelements back to middle
83 int s, n = off + len;
84 s = Math.min(a - off, b - a);
85 vecswap(x, off, b - s, s);
86 s = Math.min(d - c, n - d - 1);
87 vecswap(x, b, n - s, s);
88 // Recursivelysort non-partition-elements
89 if ((s = b - a) >1)
90 sort1(x, off, s);
91 if ((s = d - c) >1)
92 sort1(x, n - s, s);
93 }
94
95 /**
96 * Swaps x[a] with x[b].
97 */
98 privatestaticvoid swap(int x[], int a, int b) {
99 int t = x[a];
100 x[a] = x[b];
101 x[b] = t;
102 }
103
104 /**
105 * Swaps x[a.. (a+n-1)] with x[b .. (b+n-1)].
106 */
107 privatestaticvoid vecswap(int x[], int a, int b, int n) {
108 for (int i=0; i<n; i++, a++, b++)
109 swap(x, a, b);
110 }
111
112 /**
113 * Returnsthe index of the median of the three indexed integers.
114 */
115 privatestaticint med3(int x[], int a, int b, int c) {
116 return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)
117 : (x[b] > x[c] ? b : x[a]> x[c] ? c : a));
118 }
119
120 /**
121 * Checkthat fromIndex and toIndex are in range, and throw an
122 *appropriate exception if they aren't.
123 */
124 privatestaticvoid rangeCheck(int arrayLen, int fromIndex, int toIndex) {
125 if (fromIndex > toIndex)
126 thrownewIllegalArgumentException("fromIndex(" + fromIndex
127 + ") >toIndex(" + toIndex + ")");
128 if (fromIndex < 0)
129 thrownewArrayIndexOutOfBoundsException(fromIndex);
130 if (toIndex > arrayLen)
131 thrownewArrayIndexOutOfBoundsException(toIndex);
132 }
133 }
测试代码如下:
1 package com.test;
2
3 importcom.util.ArraysPrimitive;
4
5publicclass ArraysTest {
6 publicstaticvoid main(String[]args) {
7 int [] a={15,93,15,41,6,15,22,7,15,20};
8 ArraysPrimitive.sort(a);
9 for(int i=0;i<a.length;i++){
10 System.out.print(a[i]+",");
11 }
12 //结果:6,7,15,15,15,15,20,22,41,93,
13 }
14 }
2、对于Object类型源码分析如下:
部分源代码(二)如下:
1 package com.util;
2
3 importjava.lang.reflect.Array;
4
5publicclass ArraysObject {
6 privatestatic final intINSERTIONSORT_THRESHOLD = 7;
7
8 private ArraysObject() {}
9
10 publicstaticvoid sort(Object[] a){
11 //java.lang.Object.clone(),理解深表复制和浅表复制
12 Object[] aux = (Object[]) a.clone();
13 mergeSort(aux, a, 0, a.length, 0);
14 }
15
16 publicstaticvoid sort(Object[] a, int fromIndex, int toIndex) {
17 rangeCheck(a.length, fromIndex,toIndex);
18 Object[] aux = copyOfRange(a,fromIndex, toIndex);
19 mergeSort(aux, a, fromIndex, toIndex,-fromIndex);
20 }
21
22 /**
23 * Src is the source array that starts atindex 0
24 * Dest is the (possibly larger) arraydestination with a possible offset
25 * low is the index in dest to startsorting
26 * high is the end index in dest to endsorting
27 * off is the offset to generatecorresponding low, high in src
28 */
29 privatestaticvoidmergeSort(Object[] src, Object[] dest, int low,
30 int high, int off) {
31 int length = high -low;
32
33 // Insertion sorton smallest arrays
34 if (length <INSERTIONSORT_THRESHOLD) {
35 for (int i = low; i <high; i++)
36 for (int j = i; j > low&&
37 ((Comparable) dest[j -1]).compareTo(dest[j]) > 0; j--)
38 swap(dest, j, j - 1);
39 return;
40 }
41
42 // Recursivelysort halves of dest into src
43 int destLow = low;
44 int destHigh = high;
45 low += off;
46 high += off;
47 /*
48 * >>>:无符号右移运算符
49 * expression1 >>> expresion2:expression1的各个位向右移expression2
50 * 指定的位数。右移后左边空出的位数用0来填充。移出右边的位被丢弃。
51 * 例如:-14>>>2; 结果为:1073741820
52 */
53 int mid = (low +high) >>> 1;
54 mergeSort(dest, src, low, mid, -off);
55 mergeSort(dest, src, mid, high, -off);
56
57 // If list isalready sorted, just copy from src to dest. This is an
58 // optimizationthat results in faster sorts for nearly ordered lists.
59 if (((Comparable)src[mid - 1]).compareTo(src[mid]) <= 0) {
60 System.arraycopy(src, low, dest,destLow, length);
61 return;
62 }
63
64 // Merge sortedhalves (now in src) into dest
65 for (int i = destLow, p =low, q = mid; i < destHigh; i++) {
66 if (q >= high ||p < mid
67 && ((Comparable)src[p]).compareTo(src[q]) <= 0)
68 dest[i] = src[p++];
69 else
70 dest[i] = src[q++];
71 }
72 }
73
74 /**
75 * Check that fromIndex and toIndex are inrange, and throw an appropriate
76 * exception if they aren't.
77 */
78 privatestaticvoid rangeCheck(int arrayLen, int fromIndex, int toIndex) {
79 if (fromIndex >toIndex)
80 thrownewIllegalArgumentException("fromIndex(" + fromIndex
81 + ") >toIndex(" + toIndex + ")");
82 if (fromIndex < 0)
83 thrownewArrayIndexOutOfBoundsException(fromIndex);
84 if (toIndex >arrayLen)
85 thrownewArrayIndexOutOfBoundsException(toIndex);
86 }
87
88 publicstatic <T> T[]copyOfRange(T[] original, intfrom, int to) {
89 returncopyOfRange(original, from, to,(Class<T[]>) original.getClass());
90 }
91
92 publicstatic <T, U> T[]copyOfRange(U[] original, intfrom, int to,
93 Class<? extends T[]>newType) {
94 int newLength = to - from;
95 if (newLength < 0)
96 thrownewIllegalArgumentException(from + " > " + to);
97 T[] copy = ((Object) newType ==(Object) Object[].class)
98 ? (T[]) new Object[newLength]
99 : (T[])Array.newInstance(newType.getComponentType(), newLength);
100 System.arraycopy(original, from, copy, 0,
101 Math.min(original.length - from, newLength));
102 return copy;
103 }
104
105 /**
106 * Swapsx[a] with x[b].
107 */
108 privatestaticvoid swap(Object[] x, int a, int b) {
109 Object t = x[a];
110 x[a] = x[b];
111 x[b] = t;
112 }
113 }
测试代码如下:
1 package com.test;
2
3 importcom.util.ArraysObject;
4
5publicclassArraysObjectSortTest {
6 publicstaticvoid main(String[]args) {
7 Student stu1=new Student(1001,100.0F);
8 Student stu2=new Student(1002,90.0F);
9 Student stu3=new Student(1003,90.0F);
10 Student stu4=new Student(1004,95.0F);
11 Student[] stus={stu1,stu2,stu3,stu4};
12 //Arrays.sort(stus);
13 ArraysObject.sort(stus);
14 for(int i=0;i<stus.length;i++){
15 System.out.println(stus[i].getId()+" : "+stus[i].getScore());
16 }
17 /* 1002 : 90.0
18 * 1003 :90.0
19 * 1004 :95.0
20 * 1001 :100.0
21 */
22 }
23 }
24class Studentimplements Comparable<Student>{
25 privateint id; //学号
26 privatefloat score; //成绩
27 public Student(){}
28 public Student(int id,float score){
29 this.id=id;
30 this.score=score;
31 }
32 @Override
33 publicint compareTo(Student s) {
34 return (int)(this.score-s.getScore());
35 }
36 publicint getId() {
37 return id;
38 }
39 publicvoid setId(int id) {
40 this.id = id;
41 }
42 publicfloat getScore() {
43 return score;
44 }
45 publicvoid setScore(float score) {
46 this.score = score;
47 }
48 }
辅助理解代码:
1 package com.lang;
2
3public final class System {
4 //System 类不能被实例化。
5 private System() {}
6 //在 System 类提供的设施中,有标准输入、标准输出和错误输出流;对外部定义的属性
7 //和环境变量的访问;加载文件和库的方法;还有快速复制数组的一部分的实用方法。
8 /**
9 * src and dest都必须是同类型或者可以进行转换类型的数组.
10 *@param src the source array.
11 * @param srcPos starting position in thesource array.
12 *@param dest the destination array.
13 *@param destPos starting position in the destination data.
14 *@param length the number of array elements to be copied.
15 */
16 publicstatic native void arraycopy(Object src, int srcPos, Objectdest,
17 int destPos, int length);
18 }
1 package com.lang.reflect;
2
3public final class Array {
4 private Array() {}
5
6 //创建一个具有指定的组件类型和维度的新数组。
7 publicstatic ObjectnewInstance(Class<?> componentType, int length)
8 throws NegativeArraySizeException{
9 returnnewArray(componentType, length);
10 }
11
12 privatestatic native Object newArray(Class componentType, int length)
13 throws NegativeArraySizeException;
14 }
二、Arrays.asList
慎用ArrayList的contains方法,使用HashSet的contains方法代替
在启动一个应用的时候,发现其中有一处数据加载要数分钟,刚开始以为是需要load的数据比较多的缘故,查了一下数据库有6条左右,但是单独写了一个数据读取的方法,将这6万多条全部读过来,却只需要不到10秒钟,就觉得这里面肯定有问题,于是仔细看其中的逻辑,其中有一段数据去重的逻辑,就是记录中存在某几个字段相同的,就认为是重复数据,就需要将重复数据给过滤掉。这里就用到了一个List来存放这几个字段所组成的主键,如果发现相同的就不处理,代码无非就是下面这样:
1 List<string> uniqueKeyList= new ArrayList<string>();
2 //......
3 if (uniqueKeyList.contains(uniqueKey)){
4 continue;
}
根据键去查找是不是已经存在了,来判断是否重复数据。经过分析,这一块耗费了非常多的时候,于是就去查看ArrayList的contains方法的源码,发现其最终会调用他本身的indexOf方法:
7publicint indexOf(Objectelem) {
8 if (elem == null) {
9 for (int i = 0; i < size; i++)
10 if (elementData[i]==null)
11 return i;
12 } else {
13 for (int i = 0; i < size; i++)
14 if (elem.equals(elementData[i]))
15 return i;
16 }
17 return -1;
18 }
原来在这里他做的是遍历整个list进行查找,最多可能对一个键的查找会达到6万多次,也就是会扫描整个List,验怪会这么慢了。
于是将原来的List替换为Set:
Set<string> uniqueKeySet= new HashSet<string>();
//......
if (uniqueKeySet.contains(uniqueKey)) {
continue;
}
速度一下就上去了,在去重这一块最多花费了一秒钟,为什么HashSet的速度一下就上去了,那是因为其内部使用的是Hashtable,这是HashSet的contains的源码:
public boolean contains(Object o) {
returnmap.containsKey(o);
}
关于UnsupportedOperationException异常
在使用Arrays.asList()后调用add,remove这些method时出现java.lang.UnsupportedOperationException异常。这是由于Arrays.asList() 返回java.util.Arrays$ArrayList, 而不是ArrayList。Arrays$ArrayList和ArrayList都是继承AbstractList,remove,add等method在AbstractList中是默认throw UnsupportedOperationException而且不作任何操作。ArrayList override这些method来对list进行操作,但是Arrays$ArrayList没有override remove(),add()等,所以throw UnsupportedOperationException。