① java array.sort 对数字的排序方法是什么,效率怎么样api里好像没有说
效率槐碰肯定高啊，人家编写jdk源码的工程师会好意思弄个冒泡排序让你调用铅档谈？
具体方法不知道，你可以看看源码，估计是某种快蠢没速排序算法吧。
② Java数组排序 几种排序方法详细一点
JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
<1>利用Arrays带有的排序方法快速排序
publicclassTest2{
publicstaticvoidmain(String[]args){
int[]a={5,4,2,4,9,1};
Arrays.sort(a);//进行排序
for(inti:a){
System.out.print(i);
}
}
}<2>冒泡排序算法
publicstaticint[]bubbleSort(int[]args){//冒泡排序算法
for(inti=0;i<args.length-1;i++){
for(intj=i+1;j<args.length;j++){
if(args[i]>args[j]){
inttemp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
returnargs;
}<3>选择排序算法
publicstaticint[]selectSort(int[]args){//选择排序算法
for(inti=0;i<args.length-1;i++){
intmin=i;
for(intj=i+1;j<args.length;j++){
if(args[min]>args[j]){
min=j;
}
}
if(min!=i){
inttemp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
returnargs;
}<4>插入排序算法
publicstaticint[]insertSort(int[]args){//插入排序算法
for(inti=1;i<args.length;i++){
for(intj=i;j>0;j--){
if(args[j]<args[j-1]){
inttemp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}elsebreak;
}
}
returnargs;
}
③ JAVA中如何使用SORT从大到小排.
在排序中,最重要的是岁档自己实现自己的比较的行数,即是闭槐implements Comparator
实现方法 public int compare(Object o1, Object o2) 最为重要..
举个例子:
package book.arrayset;
import java.util.Comparator;
/**
* 整数比较器，将整数按降序排列
*/
class MyIntComparator implements Comparator{
/**
* o1比o2大，返回-1；o1比o2小，返回1。
*/
public int compare(Object o1, Object o2) {
int i1 = ((Integer)o1).intValue();
int i2 = ((Integer)o2).intValue();
if (i1 < i2){
return 1;
}
if (i1 > i2){
return -1;
}
return 0;
}
}
//上面的为比较的函数实现,下面真正的添加数据,
//通过调用上面的比较函数实现自定义排序的功能
package book.arrayset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 对List中的元素排序
*/
public class SortList {
public static void output(List list){
if (list == null){
return;
}
for (int i=0; i<list.size(); i++){
System.out.print(list.get(i).toString() + " ");
}
System.out.println();
}
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(5));
list.add(new Integer(8));
list.add(new Integer(1));
list.add(new Integer(3));
list.add(new Integer(2));
list.add(new Double(3.1));
System.out.println("list开始状态");
SortList.output(list);
//Collections.sort方法将用默认轿雀友比较器排列list的元素
Collections.sort(list);
System.out.println("list被默认比较器排序后的状态");
SortList.output(list);
//下面将list的元素按降序排列
Collections.sort(list, new MyIntComparator());
System.out.println("list被自定义比较器排序后的状态");
SortList.output(list);
//因此，对于任意自定义类的对象，当保存在集合类容器中后，如果需要对它们进行排序，
//需要自己提供适应于自定义类的比较器，自定义比较器必须实现Comparator接口。
//然后采用Collections.sort(list, comparator);方法对容器进行排序。
}
}
④ java Arrays.sort() 排序规则
首先，你要学会查文档，文档当中都写得清清楚楚。还有需要注意的是sort的排序是采用bubble的。只能在一般的处理，如果要求算法比较高的就不行了～但是他 能做的事情就很多了，比如说能给对象从小到大排序。等等。但是也有局限性的。具体的用法楼上也说了：
static void sort(byte[] a)
对指定的 byte 型数组按数字升序进行排序。
static void sort(byte[] a, int fromIndex, int toIndex)
对指定 byte 型数组的指定范围按数字升序进行排序。
static void sort(char[] a)
对指定的 char 型数组按数字升序进行排序。
static void sort(char[] a, int fromIndex, int toIndex)
对指定 char 型数组的指定范围按数字升序进行排序。
static void sort(double[] a)
对指定的 double 型数组按数字升序进行排序。隐信
static void sort(double[] a, int fromIndex, int toIndex)
对指定 double 型数灶亏轮组的指定范围按数字升序进行排序。
static void sort(float[] a)
对指定的 float 型数组按数字升序进行排序。
static void sort(float[] a, int fromIndex, int toIndex)
对指定 float 型数组的指定范围按数字升序进行排序。
static void sort(int[] a)
对指定的 int 型数组按数字升序进行排序。
static void sort(int[] a, int fromIndex, int toIndex)
对指定 int 型数组的指定范围按数字升序进行排序。
static void sort(long[] a)
对指定的 long 型数组按数字升序进行排序。
static void sort(long[] a, int fromIndex, int toIndex)
对指定 long 型数组的指定范围按数字升序进行排序。
static void sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序。
static void sort(Object[] a, int fromIndex, int toIndex)
根据元素的自然顺序对指定对象数组的指定范围按升序进行排序。
static void sort(short[] a)
对指定的 short 型数组按数字升序进行排序。
static void sort(short[] a, int fromIndex, int toIndex)
对指定 short 型数组的指定范围按数字升序进行排序。
static <T> void
sort(T[] a, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组进行排序。
static <T> void
sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
根据指定比较器产生的顺序对指定对象数组的空迅指定范围进行排序。
。总之记得查文档，文档里都有
⑤ java算法面试题：排序都有哪几种方法
一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比较相邻的两个数，将小数放在前面，大数放在后面
* 冒泡排序，具有稳定性
* 时间复杂度为O（n^2）
* 不及堆排序，快速排序O（nlogn，底数为2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、选择排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 选择排序
* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 选择排序是不稳定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 选择排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序后的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的数组
* @param start 排序的开始座标
* @param end 排序的结束座标
*/
public static void quickSort(int[] sort, int start, int end) {
// 设置关键数据key为要排序数组的第一个元素，
// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
int key = sort[start];
// 设置数组左边的索引，往右移动判断比key大的数
int i = start;
// 设置数组右边的索引，往左移动判断比key小的数
int j = end;
// 如果左边索引比右边索引小，则还有数据没有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
// 即保持了key左边的数比key小，key右边的数比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//递归调用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左边向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
顺便添加一份，差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍历i之前的数字
{
//如果之前的数字大于后面的数字，则把大的值赋到后面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起来的一份写法：
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、顺便贴个二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法，返回座标，不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}
⑥ 用Java实现几种常见的排序算法
用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排序、快速排序、归并排序、堆排序、SortUtil等。
插入排序：package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/*** @author treeroot
* @since 2006-2-2
* @version 1.0*/public class InsertSort implements SortUtil.Sort{
/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int temp;for(int i=1;i<data.length;i++){
for(int j=i;(j0)&&(data[j]<data[j-1]);j--){
SortUtil.swap(data,j,j-1);}}}}冒泡排序：package org.rut.util.algorithm.support;
import org.rut.util.algorithm.SortUtil;/*** @author treeroot
* @since 2006-2-2
* @version 1.0*/public class BubbleSort implements SortUtil.Sort{
/* (non-Javadoc)
* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/public void sort(int[] data) {int temp;for(int i=0;i<data.length;i++){
for(int j=data.length-1;ji;j--){
⑦ java中Arrays.sort使用的是什么算法
Arrays.sort()
先来看看Arrays.sort();，一点进这个方法会看到是这样子的
publicstaticvoidsort(int[]a){
DualPivotQuicksort.sort(a,0,a.length-1,null,0,0);
}123
果然没这么简单，DualPivotQuicksort翻译过来就是双轴快速排序，关于双轴排序可以去这里http://www.cnblogs.com/nullzx/p/5880191.html看看。那再次点进去，可以发现有这么一段代码
if(right-left<QUICKSORT_THRESHOLD){
sort(a,left,right,true);
return;
}1234
可以发现如果数组的长度小于QUICKSORT_THRESHOLD的话就会使用这个双轴快速排序，而这个值是286。
那如果大于286呢，它就会坚持数组的连续升序和连续降序性好不好，如果好的话就用归并排序，不好的话就用快速排序，看下面这段注释就可以看出
*Thearrayisnothighlystructured,
*.
123
那现在再回到上面的决定用双轴快速排序的方法上，再点进去，发现又会多一条判断
//Useinsertionsortontinyarrays
if(length<INSERTION_SORT_THRESHOLD)
123
即如果数组长度小于INSERTION_SORT_THRESHOLD(值为47)的话，那么就会用插入排序了，不然再用双轴快速排序。
所以总结一下Arrays.sort()方法，如果数组长度大于等于286且连续性好的话，就用归并排序，如果大于等于286且连续性不好的话就用双轴快速排序。如果长度小于286且大于等于47的话就用双轴快速排序，如果长度小于47的话就用插入排序。真是有够绕的~
⑧ java中的SORT怎么用
Java中的Sort（排序）通常指的是Collections.sort() 对 List 的排序，该排序方式有两种不同改的使用方法：
第一种是list中的对象实现Comparable接口，如下
public class User implements Comparable<User>{
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
public int compareTo(User arg0) {
return this.getOrder().compareTo(arg0.getOrder());
}
}
此时可以直接排序
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
//此处add user2再add user1
list.add(user2);
list.add(user1);
Collections.sort(list);
for(User u : list){
System.out.println(u.getName());
}
}
第二种方法是根据Collections.sort重载方法来实现，例如：
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
list.add(user2);
list.add(user1);
Collections.sort(list,new Comparator<User>(){
public int compare(User arg0, User arg1) {
return arg0.getOrder().compareTo(arg1.getOrder());
}
});
for(User u : list){
System.out.println(u.getName());
}
}
⑨ Java:使用sort方法对整个数组或部分数组进行排序的问题
额，他只是为了让你明白sort(char,1,3)是从第1个开始，册梁到第3个（但是不包州首运括芹段第3个）的字符进行排序。
⑩ 用JAVA实现快速排序算法
public void quickSort(int left,int right,int a[])
{
int l=left;
int r=right;
int pivot=a[(l+r)/2];//转轴数
int temp=0;
while(l<r)
{
while(a[l]<pivot)l++;
while(a[r]>pivot)r--;
if(l>=r)break;
temp=a[l];
a[l]=a[r];
a[r]=temp;
if(a[l]==pivot)r--;
if(a[r]==pivot)l++;
}
if(l==r)
{
l++;
r--;
}
if(left<r)quickSort(left,r,a);
if(right>l)quickSort(l,right,a);
}