java ayyay.sort_java.util.Arrays.sort方法

java.util.Arrays.sort方法

Modifier and Type

方法

描述

static void

sort(byte[] a)

按照数字顺序排列指定的数组。

static void

sort(byte[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(char[] a)

按照数字顺序排列指定的数组。

static void

sort(char[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(double[] a)

按照数字顺序排列指定的数组。

static void

sort(double[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(float[] a)

按照数字顺序排列指定的数组。

static void

sort(float[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(int[] a)

按照数字顺序排列指定的数组。

static void

sort(int[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(long[] a)

按照数字顺序排列指定的数组。

static void

sort(long[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(short[] a)

按照数字顺序排列指定的数组。

static void

sort(short[] a, int fromIndex, int toIndex)

按升序排列数组的指定范围。

static void

sort(Object[] a)

根据其元素的natural ordering按照升序排列指定的对象数组。

static void

sort(Object[] a, int fromIndex, int toIndex)

根据其元素的natural ordering按照升序排列指定数组对象的指定范围。

static void

sort(T[] a, int fromIndex, int toIndex, Comparator c)

根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。

static void

sort(T[] a, Comparator c)

根据指定的比较器引发的顺序对指定的对象数组进行排序。

sort(int[] a)

import java.util.Arrays;

public class TestSort {

public static void main(String[] args) {

test();

}

//测试 sort()方法

public static void test(){

int[] a = {1,2,3,5,10,8};

Arrays.sort(a);

System.out.println("排序后的数组："+Arrays.toString(a));

}

}

排序后的数组：[1, 2, 3, 5, 8, 10]

sort(int[] a, int fromIndex , int toIndex)

import java.util.Arrays;

public class TestSort {

public static void main(String[] args) {

test();

}

//测试 sort()方法

public static void test(){

int[] a = {1,2,6,5,10,8};

Arrays.sort(a,0,4);

System.out.println("0-4位元素排序后的数组："+Arrays.toString(a));

}

}

0-4位元素排序后的数组：[1, 2, 5, 6, 10, 8]

sort(T[] a, Comparator c)

import java.util.Arrays;

import java.util.Comparator;

public class TestSort {

public static void main(String[] args) {

test();

}

//测试 sort()方法

public static void test(){

String[] a = {"Natalie","小猪","Jack","miss","小花"};

Arrays.sort(a,new StringComparator());

System.out.println("排序后的字符串："+Arrays.toString(a));

}

}

class StringComparator implements Comparator {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

}

排序后的字符串：[Jack, Natalie, miss, 小猪, 小花]

s

import java.util.Arrays;

public class TestSort {

public static void main(String[] args) {

test();

}

//测试 sort()方法

public static void test(){

StringComparable[] a = {new StringComparable("Natalie",3),

new StringComparable("小猪",3),new StringComparable("Jack",2),

new StringComparable("miss",1),new StringComparable("小花",1)};

Arrays.sort(a);

StringBuilder sb = new StringBuilder();

sb.append("按id排序后的对象：[");

for (StringComparable cp : a) {

sb.append("id=").append(cp.id).append(" name=").append(cp.name).append(",");

}

sb.setCharAt(sb.length()-1,'}');

System.out.println(sb.toString());

}

}

class StringComparable implements Comparable {

int id;

String name;

public StringComparable(String name, int id) {

this.id = id;

this.name = name;

}

@Override

public int compareTo(StringComparable o) {

//升序

if (this.id > o.id) {

return 1;

}

else if (this.id < o.id) {

return -1;

}

return 0;

}

}

按id排序后的对象：[id=1 name=miss,id=1 name=小花,id=2 name=Jack,id=3 name=Natalie,id=3 name=小猪}