参考链接： Java程序的输出| 18(重写Override)
一道简单程序题：
编写一个程序，输入学生的姓名、分数信息，要求程序按照成绩降序排序后并输出。
实现方法有很多
方法一
public class ScoreSort2
{
private String name;
private long grade;
public long getGrade()
{
return grade;
}
public void setGrade(long grade)
{
this.grade = grade;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String toString()
{
return this.name;
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("情输入学生人数:");
int num = sc.nextInt(); //学生个数
ScoreSort2 message[] = new ScoreSort2[num]; //成绩信息的条数
for(int i = 0; i < message.length; i++)
{
message[i] = new ScoreSort2();
System.out.println("请输入第" + (i+1) + "个学生的姓名");
String name = sc.next();
message[i].setName(name);
System.out.println("请输入第" + (i+1) + "个学生的成绩");
long grade = sc.nextLong();
message[i].setGrade(grade);
}
System.out.println("统计结果如下:");
for(int i = 0; i < message.length; i++)
{
for(int j = i+1; j <message.length; j++)
{
if(message[i].getGrade() < message[j].getGrade())
{
ScoreSort2 s = new ScoreSort2();
s = message[i];
message[i] = message[j];
message[j] = s;
}
}
}
for(int i=0; i < message.length; i++)
{
System.out.println("姓名："+message[i].getName()+"成绩："+message[i].getGrade());
}
}
}
方法二
public class ScoreSort3
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
System.out.println("请输入学生个数");
int num = input.nextInt();
scoreData[] arr = new scoreData[num];
for(int i=0;i<num;i++)
{
System.out.println("请输入第" + (i+1) +"个学生的姓名:") ;
String stuName = input.next();//将nextLine改为next nextline只读入了数字 未读入换行
System.out.println("请输入第" + (i+1) +"个学生的成绩:");
String stuScore = input.next();
arr[i] = new scoreData(stuName,stuScore);
}
System.out.println("-----------------------");
System.out.println("降序排序结果输出：");
Arrays.sort(arr);
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
}
}
class scoreData implements Comparable
{
private String name;
private String score;
public scoreData(String name, String score)
{
this.name = name;
this.score = score;
}
//降序排序
public int compareTo(Object o)
{
scoreData s = (scoreData)o;
if(this.score.compareTo(s.score)<0)//String类型的大小比较
{
return 1;
}
else if(this.score.compareTo(s.score)>0)
{
return -1;
}
return 0;
}
@Override
public String toString(){//重写toString方法
return "姓名：" + this.name + " 成绩：" + this.score;
}
}
Arrays.sort
public static void sort(Object[] a)
根据元素的
自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须实现
Comparable 接口。此外，数组中的所有元素都必须是
可相互比较的（也就是说，对于数组中的任何
e1 和
e2 元素而言，
e1.compareTo(e2) 不得抛出
ClassCastException）。
保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
类型参数：
T - 可以与此对象进行比较的那些对象的类型
接口 Comparable<T>
类型参数：
T - 可以与此对象进行比较的那些对象的类型
public interface Comparable<T>
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
实现此接口的对象列表（和数组）可以通过 Collections.sort（和Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。注意，null 不是任何类的实例，即使e.equals(null) 返回 false，e.compareTo(null) 也将抛出 NullPointerException。
建议（虽然不是必需的）最好使自然排序与 equals 一致。这是因为在使用自然排序与 equals 不一致的元素（或键）时，没有显式比较器的有序集合（和有序映射表）行为表现“怪异”。尤其是，这样的有序集合（或有序映射表）违背了根据equals 方法定义的集合（或映射表）的常规协定。
例如，如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中，使 (!a.equals(b) && a.compareTo(b) == 0)，那么第二个add 操作将返回 false（有序集合的大小没有增加），因为从有序集合的角度来看，a 和 b 是相等的。
实际上，所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。java.math.BigDecimal 是个例外，它的自然排序将值相等但精确度不同的BigDecimal 对象（比如 4.0 和 4.00）视为相等。
从数学上讲，定义给定类 C 上自然排序的关系式 如下：
{(x, y)|x.compareTo(y) <= 0}。
整体排序的
商
是：
{(x, y)|x.compareTo(y) == 0}。
它直接遵循
compareTo
的协定，商是
C
的
等价关系
，自然排序是
C
的
整体排序
。当说到类的自然排序
与 equals 一致
时，是指自然排序的商是由类的
equals(Object)
方法定义的等价关系。
{(x, y)|x.equals(y)}。
此接口是 Java Collections Framework 的成员。
从以下版本开始：
1.2
另请参见：
Comparator
方法摘要intcompareTo(T o)比较此对象与指定对象的顺序。
方法详细信息
compareTo
int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。（这意味着如果y.compareTo(x)抛出一个异常，则 x.compareTo(y) 也要抛出一个异常。）
实现类还必须确保关系是可传递的：(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0。
最后，实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。 强烈推荐(x.compareTo(y)==0) == (x.equals(y)) 这种做法，但并不是 严格要求这样做。一般来说，任何实现Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”
在前面的描述中，符号 sgn(expression) 指定 signum 数学函数，该函数根据expression 的值是负数、零还是正数，分别返回-1、0 或 1 中的一个值。
参数：
o - 要比较的对象。
返回：
负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
抛出：
ClassCastException - 如果指定对象的类型不允许它与此对象进行比较
另附上Arrays.sort用法：
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]
6、对象数组排序
要对一个对象数组排序 ，则要自己实现java.util.Comparator接口 例子： Common_User[] userListTemp=new Common_User[temp.size()]; Arrays.sort(userListTemp, new PinyinComparator()); PinyinComparator 实现了Comparator接口，重写了compare方法，来告诉Arrays按照什么规则来比较两个对象的大小。
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
