arrays sort在Java代码中。 数组的排序代码是Arrays.sort(数组名); 这是升序的。 那逆序怎么弄？

怎样用Arrays.sort函数排序一个类对象数组

sort(a//数组的第一个元素，a+n//数组的第n个元素) a是要排的数组名

JAVA Array.sort时间排序问题

给你一个例子，希望能帮到你。 import java.util.* ; class Student{ // 指定类型为Student private String name ; private int age ; public Student(String name,int age){ this.name = name ; this.age = age ; } public boolean equals(Object obj){ // 覆写equals方法 if(this==obj){ return true ; } if(!(obj instanceof Student)){ return false ; } Student stu = (Student) obj ; if(stu.name.equals(this.name)&&stu.age==this.age){ return true ; }else{ return false ; } } public void setName(String name){ this.name = name ; } public void setAge(int age){ this.age = age ; } public String getName(){ return this.name ; } public int getAge(){ return this.age ; } public String toString(){ return name + " " + this.age ; } }; class StudentComparator implements Comparator<Student>{ // 实现比较器 // 因为Object类中本身已经有了equals()方法 public pare(Student s1,Student s2){ if(s1.equals(s2)){ return 0 ; }else if(s1.getAge()<s2.getAge()){ // 按年龄比较 return 1 ; }else{ return -1 ; } } }; public class ComparatorDemo{ public static void main(String args[]){ Student stu[] = {new Student("张三",20), new Student("李四",22),new Student("王五",20), new Student("赵六",20),new Student("孙七",22)} ; java.util.Arrays.sort(stu,new StudentComparator()) ; // 进行排序操作 for(int i=0;i<stu.length;i++){ // 循环输出数组中的内容 System.out.println(stu[i]) ; } } };

java中 Arrays.sort是升序 那什么是降序 是！Arrays.sort吗

java底层封装的soft只能升序 自己写一个soft()方法 就可以了 代码如下： public class Test { public static void main(String[] args) { int [] a=new int[]{23,56,78,4,1,5879,54}; sort(a); System.out.println(Arrays.toString(a)); } private static void sort(int[] a) { for (int i = 0; i < a.length-1; i++) { for (int j = i+1; j < a.length; j++) { if(a[j]>a[i]){ int t=a[j]; a[j]=a[i]; a[i]=t; } } } } }

Arrays.sort()方法排序。

这样只能做一个判断 将str 数组里面不为空的循环添加进一个新的数组 然后用 Arrays.sort 方法排序新的数组

在java中Arrays.sort是用来排序的，但是他可不可以用来比较两个对象的大小。怎么用Arrays.sort

展开全部 import java.util.Arrays; public class Test { public static void main(String[] args) { int[] array = new int[20]; // 随机初始化一个20个元素的数组 for (int i = 0; i < array.length; i++) { array[i] = (int) (Math.random() * 100); } // 打印数组的值 System.out.println(Arrays.toString(array)); // 排序 Arrays.sort(array); // 打印数组排序后的的值 System.out.println(Arrays.toString(array)); // 以上是对基本类型的操作，及排序的用法。如果要比较大小，基本类型直接用大于> 小于< 等于=就行了。 // 这里再给你演示一下，对象类型的操作，同样的，用Integer Integer[] arrayInt = new Integer[20]; // 随机初始化一个20个元素的数组 for (int i = 0; i < arrayInt.length; i++) { arrayInt[i] = (int) (Math.random() * 100); } // 打印数组的值 System.out.println(Arrays.toString(array)); // 排序 Arrays.sort(array); // 打印数组排序后的的值 System.out.println(Arrays.toString(array)); // 对于对象类型，要比较大小，需要继承 // java.lang.Comparable接口，实pareTo方法，Integer是已经实现了的，要比较大小可以如下; Integer a = new Integer(10); Integer b = new Integer(20); System.out.println("a和b的比较结果为：" + pareTo(b) + "，小于0，说明a小于b"); // pareTo(b)如果返回小于0，则表示a小于b，如果=0，则表示两者相等，如果大于0，则表示a大于b } }

Arrays.sort()为什么在for循环前面

有的时候需要对数组里的element进行排序。当然可以自己编写合适的排序方法，但既然java包里有自带的Arrays.sort排序方法，在 数组元素比较少的时候为何不用？ 　　Sorting an Array 1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 }; 　　Arrays.sort(intArray); 　　输出： [-23, 1, 3, 4] 　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" }; 　　Arrays.sort(strArray); 　　输出： [C, a, z] 　　3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort 　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 　　输出： [a, C, z] 　　4. 反向排序， Reverse-order sort 　　Arrays.sort(strArray, Collections.reverseOrder()); 　　输出：[z, a, C] 　　5. 忽略大小写反向排序 Case-insensitive reverse-order sort 　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 　　Collections.reverse(Arrays.asList(strArray)); 　　输出： [z, C, a] 　　java初学者最常见的错误思想，就是试图去写一些方法来完成数组的排序功能，其实，数组排序功能，在java的api里面早已实现，我们没有 必要去重复制造轮子。 　　Arrays类有一个静态方法sort,利用这个方法我们可以传入我们要排序的数组进去排序，因为我们传入的是一个数组的引用，所以排序完成的 结果也通过这个引用的来更改数组.对于整数、字符串排序，jdk提供了默认的实现，如果要对一个对象数组排序，则要自己实现 java.util.Comparator接口。 .gjh.gee.arrays; import java.util.Arrays; public class ArraySortDemo { public void sortIntArray() { int[] arrayToSort = new int[] { 48, 5, 89, 80, 81, 23, 45, 16, 2 }; System.out.println("排序前"); for (int i = 0; i < arrayToSort.length; i++) System.out.println(arrayToSort[i]); // 调用数组的静态排序方法sort Arrays.sort(arrayToSort); System.out.println("排序后"); for (int i = 0; i < arrayToSort.length; i++) System.out.println(arrayToSort[i]); } public void sortStringArray() { String[] arrayToSort = new String[] { "Oscar", "Charlie", "Ryan", "Adam", "David" }; System.out.println("排序前"); for (int i = 0; i < arrayToSort.length; i++) System.out.println(arrayToSort[i]); System.out.println("排序后"); // 调用数组的静态排序方法sort Arrays.sort(arrayToSort); for (int i = 0; i < arrayToSort.length; i++) System.out.println(arrayToSort[i]); } public void sortObjectArray() { Dog o1 = new Dog("dog1", 1); Dog o2 = new Dog("dog2", 4); Dog o3 = new Dog("dog3", 5); Dog o4 = new Dog("dog4", 2); Dog o5 = new Dog("dog5", 3); Dog[] dogs = new Dog[] { o1, o2, o3, o4, o5 }; System.out.println("排序前"); for (int i = 0; i < dogs.length; i++) { Dog dog = dogs[i]; System.out.println(dog.getName()); } Arrays.sort(dogs, new ByWeightComparator()); System.out.println("排序后："); for (int i = 0; i < dogs.length; i++) { Dog dog = dogs[i]; System.out.println(dog.getName()); } } public static void main(String[] args) { ArraySortDemo t = new ArraySortDemo(); t.sortIntArray(); t.sortStringArray(); t.sortObjectArray(); } }

java中用Arrays sort()如何将字符串倒序排列?如,将"abcdefg"排序为"gfedcba".

java中用arrays sort（）方法将abcdefg倒序，可以先试用parable接口先进行比较，然后排序，实例如下： package?test; import?java.util.Arrays; import?java.util.Comparator; public?class?Arraysort?{ ????public?static?void?main(String[]?args)?{ ????????String?s?=?"a,b,c,d,e,f,g"; ????????String[]?strArr?=?s.split(","); ????????Arrays.sort(strArr,?());//排序 ????????for(String?str?:?strArr){ ????????????System.out.print(str+","); ????????} ????} } <T>?implements?Comparator<T>?{//对abcdefg进行比较大小，排序 ????public?pare(T?o1,?T?o2)?{ ????????int?i?=?Integer.parseInt(String.valueOf(o1)); ????????int?j?=?Integer.parseInt(String.valueOf(o2)); ????????if?(i?>?j)?return?1; ????????if?(i?<?j)?return?-1; ????????return?0; ????} }

关于Java中Array.sort()排序原理，越详细越好！

是?Arrays.sort(a);?吧 给你看源码 ============= /*??????*/???public?static?void?sort(int[]?paramArrayOfInt) /*??????*/???{ /*???96?*/?????sort1(paramArrayOfInt,?0,?paramArrayOfInt.length); /*??????*/???} // /*??????*/???private?static?void?sort1(int[]?paramArrayOfInt,?int?paramInt1,?int?paramInt2) /*??????*/???{ /*??558?*/?????if?(paramInt2??paramInt1)?&&?(paramArrayOfInt[(j?-?1)]?>?paramArrayOfInt[j]);?j--) /*??561?*/???????????swap(paramArrayOfInt,?j,?j?-?1); /*??562?*/???????return; /*??????*/?????} /*??????*/????? /*??????*/? /*??566?*/?????int?i?=?paramInt1?+?(paramInt2?>>?1); /*??567?*/?????if?(paramInt2?>?7)?{ /*??568?*/???????j?=?paramInt1; /*??569?*/???????k?=?paramInt1?+?paramInt2?-?1; /*??570?*/???????if?(paramInt2?>?40)?{ /*??571?*/?????????m?=?paramInt2?/?8; /*??572?*/?????????j?=?med3(paramArrayOfInt,?j,?j?+?m,?j?+?2?*?m); /*??573?*/?????????i?=?med3(paramArrayOfInt,?i?-?m,?i,?i?+?m); /*??574?*/?????????k?=?med3(paramArrayOfInt,?k?-?2?*?m,?k?-?m,?k); /*??????*/???????} /*??576?*/???????i?=?med3(paramArrayOfInt,?j,?i,?k); /*??????*/?????} /*??578?*/?????int?j?=?paramArrayOfInt[i]; /*??????*/????? /*??????*/? /*??581?*/?????int?k?=?paramInt1;int?m?=?k;int?n?=?paramInt1?+?paramInt2?-?1;int?i1?=?n; /*??????*/?????for?(;;)?{ /*??583?*/???????if?((m?<=?n)?&&?(paramArrayOfInt[m]?<=?j))?{ /*??584?*/?????????if?(paramArrayOfInt[m]?==?j) /*??585?*/???????????swap(paramArrayOfInt,?k++,?m); /*??586?*/?????????m++; /*??????*/???????}?else?{ /*??588?*/?????????while?((n?>=?m)?&&?(paramArrayOfInt[n]?>=?j))?{ /*??589?*/???????????if?(paramArrayOfInt[n]?==?j) /*??590?*/?????????????swap(paramArrayOfInt,?n,?i1--); /*??591?*/???????????n--; /*??????*/?????????} /*??593?*/?????????if?(m?>?n) /*??????*/???????????break; /*??595?*/?????????swap(paramArrayOfInt,?m++,?n--); /*??????*/???????} /*??????*/?????} /*??????*/????? /*??599?*/?????int?i3?=?paramInt1?+?paramInt2; /*??600?*/?????int?i2?=?Math.min(k?-?paramInt1,?m?-?k);vecswap(paramArrayOfInt,?paramInt1,?m?-?i2,?i2); /*??601?*/?????i2?=?Math.min(i1?-?n,?i3?-?i1?-?1);vecswap(paramArrayOfInt,?m,?i3?-?i2,?i2); /*??????*/????? /*??????*/? /*??604?*/?????if?((i2?=?m?-?k)?>?1) /*??605?*/???????sort1(paramArrayOfInt,?paramInt1,?i2); /*??606?*/?????if?((i2?=?i1?-?n)?>?1)?{ /*??607?*/???????sort1(paramArrayOfInt,?i3?-?i2,?i2); /*??????*/?????} /*??????*/???} /*??????*/??? /*??????*/? /*??????*/???private?static?void?swap(int[]?paramArrayOfInt,?int?paramInt1,?int?paramInt2) /*??????*/???{ /*??614?*/?????int?i?=?paramArrayOfInt[paramInt1]; /*??615?*/?????paramArrayOfInt[paramInt1]?=?paramArrayOfInt[paramInt2]; /*??616?*/?????paramArrayOfInt[paramInt2]?=?i; /*??????*/???}

Java中可以用Arrays.sort()方法写这个代码吗?

import?java.util.Arrays; import?java.util.Comparator; class?odvd{????//测试用的类，dvd数据 ????String[]?name={"B","C","A","D"}; ????int[]?count={2,3,1,4}; } class?mdvd{????//用来排序的类 ????String?name; ????int?count; ????public?mdvd(String?n,int?c){ ????????name=n; ????????count=c; ????} } public?class?demo?{ ????public?static?void?main(String[]?args){ ????????odvd?dvd=new?odvd();? ????????int?n=dvd.name.length; ????????mdvd[]?dvds=new?mdvd[n];????? ????????for(int?k=0;k<n;k++) ????????????dvds[k]=new?mdvd(dvd.name[k],dvd.count[k]); ????????Arrays.sort(dvds,new?Comparator<mdvd>(){ ????????????public?pare(mdvd?a,mdvd?b){ ????????????????return?a.count-b.count; ????????????}? ????????}); ????????System.out.println("--->?排行榜 "); ????????System.out.println("**************************"); ????????System.out.println("次数 名称"); ????????for(mdvd?d:dvds) ????????????System.out.println(d.count+" <<"+?d.name?+?">>"); ????} }?如果不指定Arrays.sort()方法，可以用treeMap，代码更简单。创建一个treeMap，然后用for循环将dvd数据put进去，直接输出即可（会自动排序）

java中Arrays.sort()是降序，那升序是什么？

方法我就不写了下面给你个冒泡排序吧 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 //从小到大 for(inti?=?0;?i?<?num.length-1;?i++)?{ ???for(intj?=?0;?j?<?num.length-1-i;?j++)?{ ????if(num[j]?>?num[j+1]){ ?????inttemp?=?num[j]; ?????num[j]?=?num[j+1]; ?????num[j+1]?=?temp; ????} ???} ??} //从大到小 for(inti?=?0;?i?<?num.length-1;?i++)?{ ???for(intj?=?0;?j?<?num.length-1-i;?j++)?{ ????if(num[j]?<?num[j+1]){ ?????inttemp?=?num[j]; ?????num[j]?=?num[j+1]; ?????num[j+1]?=?temp; ????} ???} ??} ?其实 我就改变了它的判断条件

java 自定义输入值用arrays sort排序

import java.util.Arrays; import java.util.Scanner; public class SortNumber { public static void main(String[] args){ Scanner scanner = new Scanner(System.in); System.out.println("Please input the count of numbers (between 2 and 100)"); int count = scanner.nextInt(); if(count< 2 || count > 100) { throw new RuntimeException("Out of bounds"); } int[] numbers = new int[count]; for(int i = 0; i < count; i++) { numbers[i] = scanner.nextInt(); } Arrays.sort(numbers); System.out.println(Arrays.toString(numbers)); } }

JAVA Arrays.sort 方面详解

你要先把他们封装成对象，sort是对容器排序，容器内装的是对象，说这么多应该就明白了吧

JAVA数组排序Arrays.sort用法（举个个简单的例子附注释本人新手）

public ArraysTest{//定义一个公共类，名字为ArrayTest public static void main(String [] args){//程序入口方法 int [] array = {1,2,6,45,87,980,54,98};//随便定义一个乱序整型数组 Arrays.sort(array);//调用静态方法Arrays.sort()排序 for(int i = 0;ijava arrays.sort 是怎么实现的int arr[]={1,4,6,8,7,9,5,3,2}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); 请参考

java数组排序问题：array.sort()是从小到大排序，那么如何从大到小排序？

Integer [] array=new Integer[]{1,2,3,4,5}; java.util.Arrays.sort(array, new java.util.Comparator.Comparator<Integer>() { @Override public pare(Integer o1, Integer o2) { return o2-o1; } }); Comparator （比较器zd）是排序版的交方法，权这个也适合于list的排序

java中 Arrays.sort()这个函数 我想用它API中提供的sort(T[] a, Comparator<? super T> c)

楼主，你的程序思想没有错，只是在细节问题上出错了， 在使用泛型时注意：任何基本类都不能作为类型参数。虽然从Java SE 5.0开始使用了自动包装机制，包装机制解决了一些问题，但不是所有问题都能解决。 自动包装机制不能用于数组，因此无法工作。 至于Comparator和Comparable接口，给你一个简单的区分 ，Comparator接口是比较器parable 接口（能比较的，也就是默认的比较器比较，自然顺序）。 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

Java中有一个排序操作的方法:java.util.Arrays.sort.（）请问括号应该写什么

java.util.arrays类可以进行数组的排序、比较和填充。当指定数组对象为null时，这些方法都抛出nullpointexception异常。 该类直接继承自java.lang.object类。 1.sort()方法 该方法将给定数组进行升序排列，主要有以下两种语法格式： （1)static void sort(byte[] a) 将数组a中的所有元素进行升序排列 （2)static void sort(byte[] a, int fromindex, int toindex) 将数组a中的 从fromindex(包括)到toindex(不包括)区间 的元素升序排列 注： 数组的数据类型可以是int[] byte[] short[] float[] long[] double[] char[]等，甚至还可是 object[]类型，这时要求数组中的所有元素必须实parable接口，也就是保证在进行 pareto(e2)时不会抛出classcastexception异常。 没有降序排列的参数，要降序取数据可以从后到前循环

JAVA arrays.sort

Arrays.sort(ia);你的是不是写错了，多了个S

JAVA中如何用array类中的sort排序方法实现数组排序

package ch03; import java.io.*; import java.util.ArrayList; import java.util.List; public class JavaBean { //输出属性 public static void variable(PrintWriter pw,String value ) { pw.println(" private "+value+";"); } //输出有参构造器代码块 public static void parameter(PrintWriter pw,String value ) { pw.println(" this."+value+"="+value+";"); } //每个属性创建Getters和Setters方法 public static void middle(PrintWriter pw,String middle1,String middle2) { //将首字母转换大写转换 char c=middle2.charAt(0); char d=Character.toUpperCase(c); String caps = middle2.replace(c, d); pw.println(" public "+middle1+" get"+caps+"(){"+" " +" return "+middle2+";"+" " +" }" +" " +" public void"+" set"+caps+"(){"+" " +" }" +" "); } //读出文件内的行数 public static int length() { int result=0; FileReader f1=null; BufferedReader br=null; try { f1=new FileReader("D:/class.txt"); br=new BufferedReader(f1); while(br.readLine()!=null) { result++; } } catch (Exception e) { e.printStackTrace(); }finally{ try { br.close(); } catch (IOException e) { e.printStackTrace(); } } return result; } public static void main(String[] args) { //读取文件内容 FileReader f1=null; BufferedReader br=null; String [] a=new String [length()]; try { f1=new FileReader("D:/class.txt"); br=new BufferedReader(f1); for(int i=0;i<=length()-1;i++) { a[i]=br.readLine(); } } catch (Exception e) { e.printStackTrace(); } File f=new File("D:/"+a[0]+".txt"); FileWriter f2=null; PrintWriter pw=null; //将属性拆分成属性类型和属性名称，并存入新数组c中 List<String> list = new ArrayList<String>(); for(int j=1;j<a.length;j++) { String [] b=new String[2]; b=a[j].split(" "); list.add(b[0]); list.add(b[1]); } String [] c= (String[]) list.toArray(new String[1]); try { f2=new FileWriter(f); pw=new PrintWriter(f2); pw.println("public class "+a[0]+"{"+" ");//定义类名 for(int k=1;k<a.length;k++)//定义属性 { variable(pw,a[k]); } pw.print( " "); //定义有参构造器 pw.print( " public "+a[0]+"("); for(int h=1;h<a.length;h++) { pw.print(a[h]); if(h==a.length-1) { break; } pw.print(","); } pw.print(")"+"{"+" "); for(int g=1;g<=c.length;g+=2) { parameter(pw,c[g]); } pw.println(" }"); //定义无参构造器 pw.println( " public "+a[0]+"("+")"+"{"+" "+" }"+" "); //输出每个属性创建Getters和Setters方法 for(int y=0;y<=c.length-1;y+=2) { middle(pw,c[y],c[y+1]); } pw.println("}"); } catch (Exception e) { e.printStackTrace(); }finally { pw.close(); } } }

JAVA的Arrays类中 java.util.Arrays.sort与java.util.Arrays.parallelSort有什么区别？

java.util.arrays.sort用的是快速排序。 java.util.arrays.parallelsort会把array分成不同的子数组，每个子数组用sort进行排序，最后再合并排序；整个过程用ForkJoin mon pool（java.util.concurrent.ForkJoinPool）进行并发操作。

java中arrays.sort()的问题

starf[0]=new Person("张闯",3600.99,2); 改为： starf[2]=new Person("张闯",3600.99,2);，用Arrays.sort 的排序，必须保证数组里面不存在空值，不然回报空指针的异常

java array.sort用的是什么排序

用Arrays类sort()对数组元素进行降序排列： import java.util.Arrays; class SortDemo { public static void main(String[] args) { int[] vec={0,15,-14,45,20,70}; Arrays.sort(vec); System.out.println("/n"); System.out.println("降序排列

java 关于Arrays.sort

for(int i: a)功能就是遍历a数组里面的每一个元素，每遍历一个就将其值赋给i,所以如果要输出数组a里面的所有元素，for(int i: a)System.out.print( i );就行，这是JDK1.5的新特性。 如果换位String数组的话，你就要for（String i:a）

java里面Arrays类 Arrays.sort.

这叫做foreach循环。跟for循环没有关系，你不应该把它看作普通的for循环 for(int elem:arr1)是迭代的意思。将arr1的元素遍历一遍的意思。冒号之前是迭代时的临时变量，冒号之后是你要迭代的数组或者集合对象（可迭代的对象）

Java中Array.sort()的排序原理

sort的底层排序原理，我用自己的经验说说，不一定是你需要的， 它是对Object数组进行排序，优先级别是int，String， int属性ComparaTo方法。而String实现String。ComparTo方法。

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代码中。 数组的排序代码是Arrays.sort(数组名); 这是升序的。 那逆序怎么弄？

排序好 写个循环 把数组从最后一个开始向前取就好啦 示例代码： String[] strs = new String[xxx.length()]; //xxx为升序排好的数组 for(int i=xxx.length();i>=0;i--){ strs[xxx.length()-i]=xxx[i]; }