Java 关于对象之间的比较 , 容器中的数据的排序

Java对象排序

基本类型排序 :

* 就是按照数据的大小排序
* 有很多排序算法；

引用类型的排序 :

1. 内置对象排序 : 已经有了该对象的排序规则
2. 自定义类的对象的排序 : 需要自己定义对象的排序规则,依照类的内部属性排序;

内置引用数据类型之间的比较

Integer,Double等数值类 , 直接使用真实数字之间的差值

String :—-》 如果str2是str1从头开始的字串(长度不相等) ,return str1.length - str2.length;

—-》 如果str1与str2有不相等的字符串 , 则直接返回两个字符unicode字符之间的差值;

Date : 比较当前对象 和 待比较对象的getTime()之差;

实体类实现 java.lang.Comparable 接口 :

可以排序的对象需要实现Comparable 接口当中的CompareTo方法 : 返回 0 -1 1;

如下例子 : Student实体类之间使用分数来比较大小

package club.dohacker.Demo;

class Student implements Comparable<Student>{
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}
@Override
public int compareTo(Student arg0) {
return this.fenshu - arg0.fenshu;
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
if(stu1.compareTo(stu2) >0){
System.out.println("张三 的 分数 高于 李四的");
}else if(stu1.compareTo(stu2) ==0){
System.out.println("张三 的 分数 等于 李四的");
}else{
System.out.println("张三 的 分数 小于 李四的");
}

}
}

创建一个的排序器类 ,实现kjava.lang.comparetor接口 :

作用 ：

解耦 ： 独立于实体类

方便 : 便于应对各种排序规则

如下例子 : Student实体类之间使用分数来比较大小

package club.dohacker.Demo;

import java.util.Comparator;

//创建一个独立于实体，但是又是针对此实体的一个比较器
class Com implements Comparator<Student>{

@Override
public int compare(Student arg0, Student arg1) {
return arg0.getFenshu() - arg1.getFenshu();
}
}

class Student {
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
Com com = new Com();
if(com.compare(stu1,stu2) >0){
System.out.println("张三 的 分数 高于 李四的");
}else if(com.compare(stu1,stu2) == 0){
System.out.println("张三 的 分数 等于 李四的");
}else{
System.out.println("张三 的 分数 小于 李四的");
}

}
}

Collections工具类的使用

针对Comparable接口的排序 :

针对Comparator接口的排序 :

Collections.sort(List list) —-> 此类表示list中存放对象的类

必须继承了comparable接口实现了compareTo方法 ,

如下代码

package club.dohacker.Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Student  implements Comparable<Student>{
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}

@Override
public int compareTo(Student stu) {
return this.fenshu - stu.getFenshu();

}

public String toString(){
return "\n姓名 : "+this.name +"  成绩"+this.fenshu+"\n";
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
Collections.sort(list);

//输出排序的信息
System.out.println(list);

}
}

Collections.sort(Listlist,Comparator com)此类集合中的对象可以不实现Comparable接口 , 但是必须拥有一个比较器

代码如下

package club.dohacker.Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Com implements Comparator<Student>{

@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.getFenshu() - o2.getFenshu();
}

}

class Student{
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}

public String toString(){
return "\n姓名 : "+this.name +"  成绩"+this.fenshu+"\n";
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
List<Student> list = new ArrayList<Student>();
list.add(stu1);
list.add(stu2);
Collections.sort(list,new Com());

//输出排序的信息
System.out.println(list);

}
}

TreeSet

*  提供数据的排序的容器 , 数据元素不能重复
*  <font color="#FF0000">HashSet 必须重写hashCode 和 equals 方法 , 才能确保Set的核心 Map结构中的Key不重复</font>
*  TreeSet 不需重写hashCode 和 equals 方法 , 比较等于0直接判断为重复

* 针对实现了Comparable 接口的实现类 , 使用TreeSet的默认的构造器就可以了
* 针对单独使用的排序器 , 需要使用 new TreeSet(Comparator<? super E > com);来指定构造器

* 因此默认构造器中添加的元素必须实现了Comparable 接口;

*注意 ： TreeSet是在添加数据的时候进行排序的 , 所以再使用时候不要修改数据,所以将实体类的属性修改为final
在构造的时候初始化就可以了;

直接实现Comparable

package club.dohacker.Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.TreeSet;

class Student implements Comparable<Student>{
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}

public String toString(){
return "\n姓名 : "+this.name +"  成绩"+this.fenshu+"\n";
}

@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
return this.fenshu - o.getFenshu();
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
Student stu3 = new Student("王五",50);
Student stu4 = new Student("赵六",78);
Student stu5 = new Student("陈七",69);

TreeSet<Student> ts = new TreeSet<Student>();
ts.add(stu1);
ts.add(stu2);
ts.add(stu3);
ts.add(stu4);
ts.add(stu5);

//输出排序的信息
System.out.println(ts);

}
}

创建一个排序器

package club.dohacker.Demo;

import java.util.Comparator;
import java.util.TreeSet;
class Com implements Comparator<Student>{

@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
return o1.getFenshu() - o2.getFenshu();
}

}

class Student {
private String name;
private int fenshu;

//constructor

public Student(String name,int fenshu){
this.name = name;
this.fenshu = fenshu;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getFenshu() {
return fenshu;
}
public void setFenshu(int fenshu) {
this.fenshu = fenshu;
}

public String toString(){
return "\n姓名 : "+this.name +"  成绩"+this.fenshu+"\n";
}

}
public class Demo1 {

public static void main(String[] args) {
Student stu1 = new Student("张三",100);
Student stu2 = new Student("李四",90);
Student stu3 = new Student("王五",50);
Student stu4 = new Student("赵六",78);
Student stu5 = new Student("陈七",69);

//     TreeSet<Student> ts = new TreeSet<Student>();  没有实现comparable,会发生ClassCastException
TreeSet<Student> ts = new TreeSet<Student>(new Com());
ts.add(stu1);
ts.add(stu2);
ts.add(stu3);
ts.add(stu4);
ts.add(stu5);

//输出排序的信息
System.out.println(ts);

}
}

TreeMap接口如下 :

要求key值能实现了Comparable接口

否则在构造时候传入针对key元素的排序器 new TreeMap(Comparator