# 集合排序
## 集合中基本数据类型排序
**使用 Collections.sort(list) 进行排序**
1. 集合中的元素类要实现 Comparable 接口，重写 compareTo 方法；
2. 调用 Collections.sort(list) 完成排序
根据元素的*自然顺序*对指定列表按升序进行排序。
~~~Java
public class IntSort {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(5);
list.add(8);
list.add(1);
list.add(4);
System.out.print("排序前的数据: ");
for(Integer it : list) {
System.out.print(it + " ");
}
Collections.sort(list);
System.out.print("排序后的数据: ");
for(Integer it : list) {
System.out.print(it + " ");
}
System.out.print("反转后的数据: ");
Collections.reverse(list);
for(Integer it : list) {
System.out.print(it + " ");
}
}
}
~~~
## 集合中字符串排序
> 字符串是按照其首字母对应的ASCII（Unicode）码值进行排序的。
~~~java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class StringSort {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("orange");
list.add("red");
list.add("blue");
list.add("yellow");
System.out.print("排序前顺序： ");
for(String color : list) {
System.out.print(color + " ");
}
Collections.sort(list);
System.out.println();
System.out.print("排序后顺序： ");
for(String color : list) {
System.out.print(color + " ");
}
}
}
~~~
***
**对于自定义的类我们将使用Comparator和Comparable接口进行排序**
## Comparator接口
* 是可以强行对某个对象进行整体排序的比较器
* 可以将Comparator接口作为参数传递给sort方法（如 Collections.sort 或 Arrays.sort）
* Comparator接口存在int compare(T o1, T o2)方法， 用来比较排序的两个参数：
a. 如果 o1 < o2，返回负整数；
b. 如果 o1 == o2，返回0；
c. 如果 o1 > o2，返回正整数。
* boolean equals(Object obj) 指示某个其他对象是否“等于”此Comparator；此方法可以被Object类中的equals方法覆盖，不必重写。
**根据自定义的数据类型中的String类型，进行排序**
~~~Java
public class Student {
private String name;
private String code;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, String code, int age) {
super();
this.name = name;
this.code = code;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [名字=" + name + ", 学号=" + code + ", 年龄=" + age + "]";
}
}
/**
* 重写compare方法，在此方法中描写我们的排序依据
* @author LiXinRong
*
*/
public class NameComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
String name1 = o1.getName();
String name2 = o2.getName();
//compareTo()方法
//如果参数字符串等于此字符串，则返回值 0；
//如果此字符串按字典顺序小于字符串参数，则返回一个小于 0 的值；
//如果此字符串按字典顺序大于字符串参数，则返回一个大于 0 的值。
//按名字升序排序
int reult = name1.compareTo(name2);
//按名字降序排序
//int reult = name2.compareTo(name1);
return reult;
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ClassSort {
public static void main(String[] args) {
//按学生的名字升序进行排序
Student qdd = new Student("仇冬冬","001",25);
Student drm = new Student("丁润萌","002",21);
Student wc = new Student("王晨","003",25);
Student lzj = new Student("刘子杰","004",22);
Student qh = new Student("邱晗","005",22);
List<Student> list = new ArrayList<Student>();
list.add(qdd);
list.add(drm);
list.add(wc);
list.add(lzj);
list.add(qh);
System.out.println("排序前顺序：");
for(Student stu : list) {
System.out.println(stu);
}
//进行排序
Collections.sort(list, new NameComparator());
System.out.println("排序后顺序：");
for(Student stu : list) {
System.out.println(stu);
}
}
}
~~~
**按年龄的降序排序**
~~~java
import java.util.Comparator;
public class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
//按年龄进行降序排序
int age1 = o1.getAge();
int age2 = o2.getAge();
int result = age2 - age1;
return result;
}
}
public class ClassSort {
public static void main(String[] args) {
Student qdd = new Student("仇冬冬","001",25);
Student drm = new Student("丁润萌","002",21);
Student wc = new Student("王晨","003",25);
Student lzj = new Student("刘子杰","004",22);
Student qh = new Student("邱晗","005",22);
List<Student> list = new ArrayList<Student>();
list.add(qdd);
list.add(drm);
list.add(wc);
list.add(lzj);
list.add(qh);
System.out.println("排序前顺序：");
for(Student stu : list) {
System.out.println(stu);
}
////按学生的年龄降序进行排序
Collections.sort(list, new AgeComparator());
System.out.println("排序后顺序：");
for(Student stu : list) {
System.out.println(stu);
}
}
}
~~~
## Comparable接口
* 此接口强行对实现它的每个类的对象进行整体排序；
* 这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法；
* 对于集合，通过调用Collections.sort方法进行排序；
* 对于数组，通过调用Arrays.sort方法进行排序；
* int compareTo(T o) 方法，该对象（实现Comparable接口的对象）小于、等于或大于指定对象（compareTo方法中的参数对象），则分别返回负整数、零或正整数。
~~~java
public class Student implements Comparable<Student> {
private String name;
private String code;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, String code, int age) {
super();
this.name = name;
this.code = code;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [名字=" + name + ", 学号=" + code + ", 年龄=" + age + "]";
}
@Override
public int compareTo(Student stu) {
int age = this.age;
int stuAge = stu.age;
int result = age - stuAge;
return result;
}
}
public class ClassSort {
public static void main(String[] args) {
Student qdd = new Student("仇冬冬","001",25);
Student drm = new Student("丁润萌","002",21);
Student wc = new Student("王晨","003",25);
Student lzj = new Student("刘子杰","004",22);
Student qh = new Student("邱晗","005",22);
List<Student> list = new ArrayList<Student>();
list.add(qdd);
list.add(drm);
list.add(wc);
list.add(lzj);
list.add(qh);
System.out.println("排序前顺序：");
for(Student stu : list) {
System.out.println(stu);
}
////按学生的年龄升序进行排序
Collections.sort(list);
System.out.println("排序后顺序：");
for(Student stu : list) {
System.out.println(stu);
}
}
}
~~~
## 练习
问：在一个列表中存储以下元素：red、blue、orange、yellow，要求打印集合中最大和最小的元素
~~~
List<String> list = new ArrayList<String>();
list.add("red");
list.add("blue");
list.add("orange");
list.add("yellow");
Collections.sort(list);
System.out.println("最小元素：" + list.get(0));
System.out.println("最大元素：" + list.get(list.size() - 1));
~~~
问：如何去除list\<String>（存储元素如下）集合中重复的元素并排序
~~~
List<String> list = new ArrayList<String>();
list.add("1");
list.add("1");
list.add("22");
list.add("2");
list.add("3");
list.add("31");
list.add("3 1");
list.add("");
list.add("0");
list.add("\t");
~~~
答：
~~~
public class CollectionsUtil {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("1");
list.add("22");
list.add("2");
list.add("3");
list.add("31");
list.add("3 1");
list.add("");
list.add("0");
list.add("\t");
CollectionsUtil.getSingleList(list);
System.out.println(list);
}
/**
* 对list集合进行去重排序操作
* @param list
*/
public static void getSingleList(List<String> list) {
//首先实现一个set接口
Set<String> set = new HashSet<String>();
//将list集合通过addAll()方法全部添加到set集合中，并利用set集合不可存储相同元素的特性去重
set.addAll(list);
//清空list集合
list.clear();
//将去重后的set集合元素，再次添加到list集合中
list.addAll(set);
//调用Collections类的sort方法直接排序
Collections.sort(list);
}
}
~~~
写一个Student类, 包含属性code[1-30), grade[1-6], score[0-100], 所有属性都是随机生成（Math.random()方法，返回一个范围[0,1）的随机数）
要求保存这二十位同学的信息，学号（code）不得相同, 并找出分数最高的同学和分数最低的同学, 最后打印输出最高分和最低分同学信息.
~~~
public class Student implements Comparable<Student> {
private int code;
private int grade;
private int score;
public Student() {
}
public Student(int code, int grade, int score) {
super();
this.code = code;
this.grade = grade;
this.score = score;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student [code=" + code + ", grade=" + grade + ", score=" + score + "]";
}
public int compareTo(Student o) {
return (int) (this.score - o.score);
}
}
List<Student> list = new ArrayList<Student>();
Set<Integer> set = new HashSet<Integer>();
while(set.size() <= 20) {
//范围大的数据强制赋给范围小的数据会出现精度缺失
int code = (int)(Math.random() * 29 + 1);
set.add(code);
}
for(Integer code : set) {
int grade = (int)(Math.random() * 6 + 1);
int score = (int)(Math.random() * 100 + 1);
list.add(new Student(code, grade, score));
}
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
Student stu = it.next();
System.out.println(stu);
}
Collections.sort(list);
System.out.println("================最大最小值为===============");
System.out.println(list.get(0));
System.out.println(list.get(list.size() - 1));
~~~
- JAVA基础
- JAVA开发准备
- JAVA介绍
- 开发JAVA的准备
- JAVA的运行原理
- JDK配置
- 我的第一个JAVA程序
- 类与对象
- 基础语言要素
- 数据类型
- eclipse的安装与使用
- 变量
- 直接量
- 运算符
- 流程控制
- 数组结构
- 面向对象
- 隐藏与封装
- 深入构造器
- 类的继承
- 多态
- 包装类
- final修饰符
- 抽象类
- 接口
- 内部类
- 设计模式
- 单例模式
- 工厂模式
- 集合框架
- 集合排序
- 常用类学习
- 异常处理
- Java基础测试
- 综合案例一
- JAVA高级
- 泛型
- 多线程
- 线程的创建
- 线程的生命周期
- 线程同步
- 线程通信
- 输入输出流(I/O编程)
- File文件操作
- 字节流与字符流
- 数据库
- 数据库介绍
- 数据库安装
- SQL
- 表的基本操作
- 修改数据语句
- 数据检索操作
- 多表数据操作
- 表结构设计
- 综合应用