Java工具类提供的排序功能 -
- ITeye技术网站
博客分类：
今天好好地巩固了一下基础，仔细研究了一下，其实Java工具类真的非常丰富，它已经提供了各种排序功能的实现：
1.数组排序
java.util.Arrays类提供了各种对象的排序：char[],byte[],long[],int[]和Object[],注Arrays.sort方法排序返回的结果是升序Ascending的排列顺序。你可以定制排序顺序。这个排序和TreeSet的红黑树排序方式不同，Set不允许有重复数据存在，因此，当有重复数据时，可以使用这个工具类进行排序。Arrays提供的排序算法是归并排序算法（当元素数量小于=7时采用的是插入排序），空间复杂度O(n)。
*&p&Test&/p&
*&p&Description:&/P&
*&p&Company:&/p&
*&p&Department:CAS&/p&
*@Author: Tommy Zhou
*@Since: 1.0
*@Version:Date:
public class ArraySortTest {
public static void main(String[] args) {
String[] strs = new String[]{"3","2","5","6","2"};
Arrays.sort(strs, String.CASE_INSENSITIVE_ORDER);
另外你还可以指定排序的方式，例如你要修改排序的顺序，由默认的升序改成降序的方式：
import java.util.A
*&p&Test&/p&
*&p&Description:&/P&
*&p&Company:&/p&
*&p&Department:CAS&/p&
*@Author: Tommy Zhou
*@Since: 1.0
*@Version:Date:
public class ArraySortTest {
public static void main(String[] args) {
String[] strs = new String[]{"3","2","5","6","2"};
Comparator comparator
= new Comparator&String&() {
public int compare(String o1, String o2) {
int c1 = Integer.valueOf(o1);
int c2 = Integer.valueOf(o2);
return c2-c1;
Arrays.sort(strs,comparator);
for (int i = 0; i & strs. i++) {
System.out.println(strs[i]);
另外你也可以下列方法指定排列的顺序是降序还是升序：
String[] strs1 = new String[]{"3","2","5","6","2"};
Arrays.sort(strs1,Collections.reverseOrder());
for (int i = 0; i & strs. i++) {
System.out.println(strs[i]);
2.TreeSet对非重复元素进行排序
TreeSet的实现依赖于TreeMap，使用了红黑树进行了排序：
import java.util.I
import java.util.TreeS
*&p&Test&/p&
*&p&Description:&/P&
*&p&Company:&/p&
*&p&Department:CAS&/p&
*@Author: Tommy Zhou
*@Since: 1.0
*@Version:Date:
public class TreeSetSortTest {
public static void main(String[] args) {
TreeSet&String& treeSet = new TreeSet&String&();
String[] strs = new String[]{"3","5","6","2"};
for (int i = 0; i & strs. i++) {
treeSet.add(strs[i]);
//Decending sorted iterator
Iterator iterator = treeSet.descendingIterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
//Ascending sorted iterator
Iterator iterator1 = treeSet.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
3.利用集合工具类进行排序
import java.util.A
import java.util.C
*&p&Test&/p&
*&p&Description:&/P&
*&p&Company:&/p&
*&p&Department:CAS&/p&
*@Author: Tommy Zhou
*@Since: 1.0
*@Version:Date:
public class CollectionsSortTest {
public static void main(String[] args) {
//Ascending sorted iterator
String[] strs = new String[]{"3","2","5","6","2"};
Collections.sort(Arrays.asList(strs));
for (int i = 0; i & strs. i++) {
System.out.println(strs[i]);
//Decending sorted iterator
String[] strs1 = new String[]{"3","2","5","6","2"};
Collections.sort(Arrays.asList(strs1),Collections.reverseOrder());
for (int i = 0; i & strs1. i++) {
System.out.println(strs1[i]);
关于红黑树的JDK实现细节和原理，请参考：
/developerworks/cn/java/j-lo-tree/index.html?ca=drs-
浏览: 314254 次
来自: 杭州
fengchuizhuming 写道楼主的完全正确。鉴定完毕楼 ...
uule 写道这个测试后结果为：“testPageConten ...
楼主的完全正确。鉴定完毕java类库中Arrays的排序算法探析（基础类型） - 寻找小包子 - ITeye技术网站
博客分类：
java.util.Arrays中有非常方便的array转换为list的方法，在已经提及了，这里再介绍下其中的排序算法：
在java.util.Arrays中，排序（sort）部分占的篇幅最大，大量用到了重载，一种是根据参数类型的重载，也就是如：
public static void sort(long[] a)；
public static void sort(int[] a)；
另外一种就是参数个数的重载，是和上面的相对应的：
public static void sort(int[] a)；
public static void sort(int[] a, int fromIndex, int toIndex)；
其实在原理上都差不多，第一种重载是根据传入数组的类型选择对应的排序；第二种是根据传入的条件多少来决定，下面以
long[]的实现为例初步分析下过程：
public static void sort(long[] a) {
sort1(a, 0, a.length);
其相同类型的重载为：
public static void sort(long[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
sort1(a, fromIndex, toIndex-fromIndex);
可以看出，有起始限制的sort首先是验证传入的起始限界是否合法，而没有起始限制的sort默认就是全排序了：/**
* Sorts the specified sub-array of longs into ascending order.
private static void sort1(long x[], int off, int len) {
// Insertion sort on smallest arrays
//如果待排序的范围很小，就选择插入排序，最是简洁,复杂度O(n2)
if (len & 7) {
for (int i= i&len+ i++)
for (int j=i; j&off && x[j-1]&x[j]; j--)
swap(x, j, j-1);
// Choose a partition element, v
//选择快排，先找出一个分区值，这里有个小技巧，取一半时采用的是移位，比
有时候使用的len/2要好一点，预设为中间位置的值
int m = off + (len && 1);
// Small arrays, middle element
if (len & 7) {
int n = off + len - 1;
if (len & 40) {
// Big arrays, pseudomedian of 9，就是找9点点来确定更好的分区点，下面可以看出，这9个点是较均匀的插值，med3是计算x数组中后面三个位置上的哪个值在中间的一个方法
int s = len/8;
l = med3(x, l,
l+s, l+2*s);
m = med3(x, m-s,
n = med3(x, n-2*s, n-s, n);
m = med3(x, l, m, n); // Mid-size, med of 3，找到分区值
long v = x[m];
// Establish Invariant: v* (&v)* (&v)* v*，其实就是构建区域，和分区值相等的区域，所有元素都小于分区值的区域，所有元素都大于分区值的区域，和分区值相等的区域
int a = off, b = a, c = off + len - 1, d =
while(true) {
//将与分区值相等的值移到头部，尾部为全部小于分区值的元素
while (b &= c && x[b] &= v) {
if (x[b] == v)
swap(x, a++, b);
//将与分区值相等的值移到尾部，头部为全部大于分区值的元素
while (c &= b && x[c] &= v) {
if (x[c] == v)
swap(x, c, d--);
//中止条件
if (b & c)
swap(x, b++, c--);
// Swap partition elements back to middle，交换，成为三个区域，分别为小于、等于和大于分区值的三个
int s, n = off +
s = Math.min(a-off, b-a
vecswap(x, off, b-s, s);
s = Math.min(d-c,
vecswap(x, b,
// Recursively sort non-partition-elements，在两边的区域递归
if ((s = b-a) & 1)
sort1(x, off, s);
if ((s = d-c) & 1)
sort1(x, n-s, s);
区域交换算法，简洁美：
* Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
private static void vecswap(long x[], int a, int b, int n) {
for (int i=0; i&n; i++, a++, b++)
swap(x, a, b);
返回三个数中间数的算法，稍微有点晕：
* Returns the index of the median of the three indexed longs.
private static int med3(long x[], int a, int b, int c) {
return (x[a] & x[b] ?
(x[b] & x[c] ? b : x[a] & x[c] ? c : a) :
(x[b] & x[c] ? b : x[a] & x[c] ? c : a));
关于long数组的排序就结束了！
其它基本类型如int, byte, char处理过程完全类似；
folat和double的后期处理也一样，只是会多一个初始化过程，这是由于浮点数的特性决定的，以float为例，在执行sort1之前的预处理：
private static void sort2(float a[], int fromIndex, int toIndex) {
final int NEG_ZERO_BITS = Float.floatToIntBits(-0.0f);
* The sort is done in three phases to avoid the expense of using
* NaN and -0.0 aware comparisons during the main sort.避免事实上不需要比较，如NaN，-0.0和0.0事实上相等等
* Preprocessing phase:
Move any NaN's to end of array, count the
* number of -0.0's, and turn them into 0.0's.预处理阶段，将NaN移到队尾，计算-0.0的个数并转换为0.0
int numNegZeros = 0;
int i = fromIndex, n = toI
while(i & n) {
if (a[i] != a[i]) {
float swap = a[i];
a[i] = a[--n];
if (a[i]==0 && Float.floatToIntBits(a[i])==NEG_ZERO_BITS) {
a[i] = 0.0f;
numNegZeros++;
// Main sort phase: quicksort everything but the NaN's，主流程，和上面long的除了数组类型和元素类型不同之外完全相同
sort1(a, fromIndex, n-fromIndex);
// Postprocessing phase: change 0.0's to -0.0's as required。后处理阶段，将之前转换为0.0的归位为-0.0
if (numNegZeros != 0) {
int j = binarySearch0(a, fromIndex, n, 0.0f); // posn of ANY zero
} while (j&=0 && a[j]==0.0f);
// j is now one less than the index of the FIRST zero
for (int k=0; k&numNegZ k++)
a[++j] = -0.0f;
在传入对象数组的时候，采用的是归并排序，算法和上面的快排有所区别，后面探讨。
jiangshuiy
浏览: 197404 次
来自: 杭州
jianyan163qq 写道好文章!我现在遇到一个调用的问题 ...
exec可能存在注入漏洞，如何控制安全问题啊？
面向对象涉及原则：1.开闭原则2.少用继承，多用聚合3.针对接 ...4244人阅读
Java编程使用现有的类库是一个很高的捷径，使得代码便于阅读和维护，那如何使用现有的类库对数组和各种Collection容器进行排序呢？
首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Collection是集合框架的顶层接口，而Collections是包含了许多静态方法。我们使用Arrays对数组进行排序，使用 Collections对结合框架容器进行排序，如ArraysList,LinkedList等。
例子中都要加上import java.util.*和其他外壳代码，如类和静态main方法，我会在第一个例子里写出全部代码，接下来会无一例外的省略。
对数组进行排序
比如有一个整型数组：
int[] intArray = new int[] {4, 1, 3, -23};
我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法：
int[] intArray = new int[] {4, 1, 3, -23};
我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法：
import java.util.*; public class Sort{ public static void main(String[] args){ int[] intArray = new int[] {4, 1, 3, -23}; Arrays.sort(intArray); } }
这样我们就用Arrays的静态方法sort()对intArray进行了升序排序，现在数组已经变成了{-23,1,3,4}.如果是字符数组:String[] strArray = new String[] {&z&, &a&, &C&}; 我们用：Arrays.sort(strArray); 进行排序后的结果是{C,a,z},sort()会根据元素的自然顺序进行升序排序。如果希望对大小写不敏感的话可以这样写：Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序，其他部分保持不变，我们可以使用:Arrays.sort(strArray,0,2); 这样，我们只对前三个元素进行了排序，而不会影响到后面的部分。当然有人会想，我怎样进行降序排序？在众多的sort方法中有一个sort(T[] a, Comparator&? super T& c) 我们使用Comparator获取一个反序的比较器即可，Comparator会在稍后讲解，以前面的intArray[]为例：Arrays.sort(intArray,Comparator.reverseOrder()); 这样，我们得到的结果就是{4,3,1,-23}。如果不想修改原有代码我们也可以使用：Collections.reverse(Arrays.asList(intArray)); 得到该数组的反序。结果同样为4,3,1,-23}。现在的情况变了，我们的数组里不再是基本数据类型(primtive type)或者String类型的数组，而是对象数组。这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口，比如我们有一个Name类：class Name implements Comparable{
public String firstName,lastN
public Name(String firstName,String lastName){
this.firstName=firstN
this.lastName=lastN
public int compareTo(Name o) {
//实现接口
int pareTo(o.lastName);
return (lastCmp!=0?pareTo(o.firstName));
public String toString(){
//便于输出测试
return firstName+& &+lastN
这样，当我们对这个对象数组进行排序时，就会先比较lastName，然后比较firstName 然后得出两个对象的先后顺序，就像compareTo(Name o)里实现的那样。不妨用程序试一试： import java.util.*;
public class NameSort {
public static void main(String[] args) {
Name nameArray[] = {
new Name(&John&, &Lennon&),
new Name(&Karl&, &Marx&),
new Name(&Groucho&, &Marx&),
new Name(&Oscar&, &Grouch&)
Arrays.sort(nameArray);
for(int i=0;i&NAMEARRAY.LENGTH;I++){ SPAN
System.out.println(nameArray[i].toString());
结果正如我们所愿：Oscar Grouch
John Lennon
Groucho Marx
Karl Marx 对集合框架进行排序如果已经理解了Arrays.sort()对数组进行排序的话，集合框架的使用也是大同小异。只是将Arrays替换成了Collections,注意Collections是一个类而Collection是一个接口，虽然只差一个&s&但是它们的含义却完全不同。假如有这样一个链表：LinkedList list=new LinkedList();
list.add(4);
list.add(34);
list.add(22);
list.add(2); 我们只需要使用:Collections.sort(list); 就可以将ll里的元素按从小到大的顺序进行排序，结果就成了:[2, 4, 22, 34] 如果LinkedList里面的元素是String，同样会想基本数据类型一样从小到大排序。如果要实现反序排序也就是从达到小排序:Collections.sort(list,Collectons.reverseOrder()); 如果LinkedList里面的元素是自定义的对象，可以像上面的Name对象一样实现Comparable接口，就可以让Collection.sort()为您排序了。如果你想按照自己的想法对一个对象进行排序，你可以使用sort(List list, Comparator&? super T& c) 这个方法进行排序，在给出例子之前，先要说明一下Comparator的使用，Comparable接口的格式：public interface Comparator {
int compare(T o1, T o2);
其实Comparator里的int compare(T o1,T o2)的写法和Comparable里的compareTo()方法的写法差不多。在上面的Name类中我们的比较是从LastName开始的，这是西方 人的习惯，到了中国，我们想从fristName开始比较，又不想修改原来的代码，这个时候，Comparator就可以派上用场了：final Comparator FIRST_NAME_ORDER=new Comparator() {
public int compare(Name n1, Name n2) {
int firstCmp=pareTo(n2.firstName);
return (firstCmp!=0?firstCmp:pareTo
(n2.firstName));
这样一个我们自定义的Comparator FIRST_NAME_ORDER就写好了。将上个例子里那个名字数组转化为List:List list=Arrays.asList(nameArray);
Collections.sort(list,FIRST_NAME_ORDER); 这样我们就成功的使用自己定义的比较器设定排序。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：184811次
积分：3477
积分：3477
排名：第7669名
原创：160篇
转载：34篇
评论：68条
(1)(3)(4)(1)(7)(4)(2)(6)(6)(4)(1)(1)(2)(1)(4)(1)(2)(1)(3)(5)(1)(4)(3)(1)(1)(1)(2)(4)(12)(11)(13)(1)(13)(12)(57)Java类的基本运行顺序
作为程序员，应该对自己写的程序具备充分的掌控能力，应该清楚程序的基本运行过程，否则糊里糊涂的，不利于对程序的理解和控制，也不利于技术上的发展。
我们以下面的类来说明一个基本的类的运行顺序：
第1行 public class Test {
第2行 private String name = "Java私塾";
第3行 private int age = 2;
第4行 public Test(){
第5行 age = 1000;//期望能到1000年，呵呵
第7行 public static void main(String[] args) {
第8行 Test t = new Test();
第9行 System.out.println(t.name+"的年龄是"+t.age+"年");
运行的基本顺序是：
（1）：先运行到第7行，这是程序的入口
（2）：然后运行到第8行，这里要new一个Test，就要调用Test的构造方法
（3）：就运行到第4行，注意：可能很多人觉得接下来就应该运行第5行了，错！初始化一个类，必须先初始化它的属性
（4）：因此运行到第2行，然后是第3行
（5）：属性初始化完过后，才回到构造方法，执行里面的代码，也就是第5行
（6）：然后是第6行，表示new一个Test实例完成
（7）：然后回到main方法中执行第9行
（8）：然后是第10行
运行的结果是：Java私塾的年龄是1000年
说明：这里只是说明一个基本的运行过程，没有考虑更多复杂的情况。
继承中：初始化子类必先初始化父类
有继承的类在运行的时候，一定要记得：初始化子类必先初始化父类，这是Java程序的一个基本运行过程。比如：
第1行public class Test extends Parent{
第2行 private String name = "Java私塾";
第3行 private int age = 2;
第4行 public Test(){
第5行 age = 1000;//期望能到1000年，呵呵
第7行 public static void main(String[] args) {
第8行 Test t = new Test();
第9行 System.out.println(t.name+"的年龄是"+t.age+"年");
第12行class Parent{
第13行 private int num = 1;
第14行 public Parent(){
第15行 System.out.println("现在初始化父类");
第17行 public void test(){
第18行 System.out.println("这是父类的test方法");
上述类的基本运行顺序是：
（1）：先运行到第7行，这是程序的入口
（2）：然后运行到第8行，这里要new一个Test，就要调用Test的构造方法
（3）：就运行到第4行，注意：初始化子类必先初始化父类
（4）：要先初始化父类，所以运行到第14行
（5）：然后是第13行，初始化一个类，必须先初始化它的属性
（6）：然后是第15行
（7）：然后是第16行，表示父类初始化完成
（8）：然后是回到子类，开始初始化属性，因此运行到第2行，然后是第3行
（9）：子类属性初始化完过后，才回到子类的构造方法，执行里面的代码，也就是第5行
（10）：然后是第6行，表示new一个Test实例完成
（11）：然后回到main方法中执行第9行
（12）：然后是第10行
运行结果是：
现在初始化父类
Java私塾的年龄是1000年
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'}