java中的数组与集合的排序---摘抄自:http://blog.csdn.net/jonathan_q_bo/archive/2005/11/29/539043.aspx

简介:

java中的数组与集合的排序

两种需要排序的对象:数组和集合

1、集合

java.util.Collections类提供了排序方法sort();

static void sort(List list) 
          Sorts the specified list into ascending order, according to the natural ordering of its elements.
static void sort(List list, Comparator c) 
          Sorts the specified list according to the order induced by the specified comparator.

       两种排序方式:
      1)被排序对象实现java.lang.Comparable接口,在其中的compareTo()方法中确定排序规则
      2)用java.util.Comparator的具体实例确定排序规则

2、数组

java.util.Arrays类提供了各种重载的排序方法sort();

static void sort(byte[] a) 
          Sorts the specified array of bytes into ascending numerical order.
static void sort(byte[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of bytes into ascending numerical order.
static void sort(char[] a) 
          Sorts the specified array of chars into ascending numerical order.
static void sort(char[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of chars into ascending numerical order.
static void sort(double[] a) 
          Sorts the specified array of doubles into ascending numerical order.
static void sort(double[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of doubles into ascending numerical order.
static void sort(float[] a) 
          Sorts the specified array of floats into ascending numerical order.
static void sort(float[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of floats into ascending numerical order.
static void sort(int[] a) 
          Sorts the specified array of ints into ascending numerical order.
static void sort(int[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of ints into ascending numerical order.
static void sort(long[] a) 
          Sorts the specified array of longs into ascending numerical order.
static void sort(long[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of longs into ascending numerical order.
static void sort(Object[] a) 
          Sorts the specified array of objects into ascending order, according to the natural ordering of its elements.
static void sort(Object[] a, Comparator c) 
          Sorts the specified array of objects according to the order induced by the specified comparator.
static void sort(Object[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of objects into ascending order, according to the natural ordering of its elements.
static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) 
          Sorts the specified range of the specified array of objects according to the order induced by the specified comparator.
static void sort(short[] a) 
          Sorts the specified array of shorts into ascending numerical order.
static void sort(short[] a, int fromIndex, int toIndex) 
          Sorts the specified range of the specified array of shorts into ascending numerical order.

如果对int[]等类型可直接升序排序
如果对Object[]类型排序,需要确定排序顺序,仍旧两种方式,被排序类本身实现Comparable接口或者提供java.util.Comparator类。

 /*
 * Created on 2005-11-27
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package sort;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
//import java.util.Random;
import java.lang.Math;

/**
 * @author Jonathan
 *
 * <b>排序方法汇总</b>
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class SortCollection{

 private void sortByComparableOfList(){
  ArrayList al = new ArrayList();
  for(int i = 0; i < 10; i++){
   int tmp = (int)(Math.random()*10);
   al.add(new SortedObjectOne(tmp,"List." + i));
  }
  Collections.sort(al);
  Iterator itt = al.iterator();
  while(itt.hasNext())
   System.out.println(itt.next());
 }
 
 private void sortByComparatorOfList(){
  ArrayList al = new ArrayList();
  for(int i = 0; i < 10; i++){
   int tmp = (int)(Math.random()*10);
   al.add(new SortedObjectOne(tmp,"List." + i));
  }
  Collections.sort(al, new SortOrderAsc());
  Iterator itt = al.iterator();
  while(itt.hasNext())
   System.out.println(itt.next());
 }
 
 /**整形数组的默认排序*/
 private void sortByDefaultOfArray(){
  int[] array = new int[10];
  for(int i = 0; i < array.length; i++){
   array[i] = (int)(Math.random()*10);
  }
  Arrays.sort(array);
  for(int i = 0; i < array.length; i++){
   System.out.println("<Array" + i + ">:<" + array[i] + ">");
  }
 }
 
 /**对象数组的默认排序*/
 private void sortByComparableOfArray(){
  SortedObjectOne[] array = new SortedObjectOne[10];
  for(int i = 0; i < array.length; i++){
   array[i] = new SortedObjectOne((int)(Math.random()*10), "Array" + i);
  }
  Arrays.sort(array);
  for(int i = 0; i < array.length; i++){
   System.out.println(array[i]);
  }
 }
 
 /**对象数组的定制排序*/
 private void sortByComparatorOfArray(){
  SortedObjectOne[] array = new SortedObjectOne[10];
  for(int i = 0; i < array.length; i++){
   array[i] = new SortedObjectOne((int)(Math.random()*10), "Array" + i);
  }
  Arrays.sort(array, new SortOrderAsc());
  for(int i = 0; i < array.length; i++){
   System.out.println(array[i]);
  }
 }
 
 public static void main(String args[]){
  SortCollection sc = new SortCollection();
  System.out.println("-- sort list by comparable --");
  sc.sortByComparableOfList();
  System.out.println("-- sort list by comparator --");
  sc.sortByComparatorOfList();
  System.out.println("-- sort array by default --");
  sc.sortByDefaultOfArray();
  System.out.println("-- sort array by comparable --");
  sc.sortByComparableOfArray();
  System.out.println("-- sort array by comparator --");
  sc.sortByComparatorOfArray();
 }
 
}

/** 根据Comparable接口确定排序顺序 */
class SortedObjectOne implements Comparable{
 
 public int attr1;
 public String attr2;
 
 public SortedObjectOne(int attr1,String attr2){
  this.attr1 = attr1;
  this.attr2 = attr2;
 }
 
 /* (non-Javadoc)
  * @see java.lang.Comparable#compareTo(java.lang.Object)
  */
 public int compareTo(Object arg0) {
  // TODO Auto-generated method stub
  if(arg0 instanceof SortedObjectOne){
   SortedObjectOne obj = (SortedObjectOne)arg0;
   return this.attr1 - obj.attr1;
  }
  return 0;
 }
 
 
 /* (non-Javadoc)
  * @see java.lang.Object#toString()
  */
 public String toString() {
  // TODO Auto-generated method stub
  return "<" + this.attr2 + ">:<" + this.attr1 + ">";
 }
}


/** 根据Comparator确定排序顺序 */
class SortOrderAsc implements Comparator{

 /* (non-Javadoc)
  * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
  */
 public int compare(Object arg0, Object arg1) {
  // TODO Auto-generated method stub
  if(arg0 instanceof SortedObjectOne && arg1 instanceof SortedObjectOne){
   SortedObjectOne tmp0 = (SortedObjectOne)arg0;
   SortedObjectOne tmp1 = (SortedObjectOne)arg1;
   return tmp1.attr1 - tmp0.attr1;
  }
  return 0;
 }

}

程序执行结果:

 -- sort list by comparable --
<List.3>:<0>
<List.9>:<0>
<List.0>:<1>
<List.1>:<1>
<List.4>:<1>
<List.6>:<3>
<List.8>:<3>
<List.5>:<7>
<List.2>:<8>
<List.7>:<9>
-- sort list by comparator --
<List.7>:<5>
<List.1>:<4>
<List.2>:<3>
<List.8>:<3>
<List.3>:<2>
<List.5>:<2>
<List.9>:<2>
<List.0>:<0>
<List.4>:<0>
<List.6>:<0>
-- sort array by default --
<Array0>:<1>
<Array1>:<2>
<Array2>:<2>
<Array3>:<6>
<Array4>:<7>
<Array5>:<8>
<Array6>:<8>
<Array7>:<9>
<Array8>:<9>
<Array9>:<9>
-- sort array by comparable --
<Array2>:<0>
<Array1>:<1>
<Array7>:<1>
<Array9>:<3>
<Array0>:<4>
<Array8>:<4>
<Array5>:<5>
<Array6>:<5>
<Array3>:<8>
<Array4>:<9>
-- sort array by comparator --
<Array3>:<9>
<Array7>:<9>
<Array1>:<7>
<Array4>:<5>
<Array5>:<3>
<Array8>:<3>
<Array0>:<2>
<Array2>:<1>
<Array6>:<1>
<Array9>:<0>

本文转自kenty博客园博客,原文链接http://www.cnblogs.com/kentyshang/archive/2007/07/04/805265.html如需转载请自行联系原作者

kenty
相关文章
|
4天前
|
Java
Java排序
【2月更文挑战第7天】【2月更文挑战第17篇】List对象集合自定义排序,列出了以前的用法以及新用法。
14 0
|
5天前
|
存储 安全 算法
Java泛型与集合:类型安全的集合操作实践
Java泛型与集合:类型安全的集合操作实践
|
5天前
|
存储 Java
Java TreeMap:基于红黑树的排序映射解析
Java TreeMap:基于红黑树的排序映射解析
|
5天前
|
安全 Java
Java TreeSet:基于红黑树的排序集合解析
Java TreeSet:基于红黑树的排序集合解析
|
5天前
|
存储 安全 Java
Java集合框架概述:体系结构与核心接口
Java集合框架概述:体系结构与核心接口
|
5天前
|
存储 算法 安全
Java中的集合框架及其应用
Java中的集合框架及其应用
|
7天前
|
Java
Java对list集合元素进行排序的几种方式
Java对list集合元素进行排序的几种方式
13 0
|
8天前
|
Java
java 实现Comparable接口排序,升序、降序、倒叙
java 实现Comparable接口排序,升序、降序、倒叙
9 0
|
11天前
|
Java
百度搜索:蓝易云【Java中如何向一个string类型的数组中添加数据】
在上述代码中,我们首先创建一个新的String数组 `newArray`,长度为原数组 `originalArray`的长度加1。然后,通过循环将原数组中的元素复制到新数组中。最后,将新数据 `newData`添加到新数组的末尾。现在,`newArray`就包含了原数组的所有元素,并且在末尾添加了新的数据。 买CN2云服务器,免备案服务器,高防服务器,就选蓝易云。百度搜索:蓝易云
9 0
|
19天前
|
Java
怎么创建多线程数组java
怎么创建多线程数组java
21 6

相关产品

  • 云迁移中心