对象数组排序 和 类比JDK实现 sort()的方法

1.定义自己的 MyComparable 接口

package Test.treeSetDemo;

public interface MyComparable <E>{
     int compareTo(E e);
}

2.定义自己的 MyComparator接口

package Test.treeSetDemo;

public interface MyComparator {
     int compare(Student  student1,Student  student2);
}

3.定义自己的排序类 

package Test.treeSetDemo;

import java.util.ArrayList;
import java.util.Comparator;

public class MyArray {
    private ArrayList <Student> students = new ArrayList<>();
    /*
        1.直接排序 实现对象的排序
        缺点:1.只能根据年龄排序
             2.只能排一种顺序 无法先年龄后身高
     */
    public void sort(){
        //使用冒泡排序比较年龄 排ArrayList中的对象
        for (int i = 0; i < students.size(); i++) {
            for (int j = 0; j < students.size()-1; j++) {
                Student current = students.get(j);
                Student next = students.get(j + 1);
                if (current.getAge()>next.getAge()){
                    Student temp = current;
                    students.set(j,next);
                    students.set(j+1,temp);
                }
            }
        }
    }

    /*
        2.让对象可比 即对象实现comparable
     */
    public void sort2(){
        //使用冒泡排序比较年龄 排ArrayList中的对象
        for (int i = 0; i < students.size(); i++) {
            for (int j = 0; j < students.size()-1; j++) {
                Student current = students.get(j);
                Student next = students.get(j + 1);
                if (current.compareTo(next)>0){
                    Student temp = current;
                    students.set(j,next);
                    students.set(j+1,temp);
                }
            }
        }
    }
    /*
        3.传入一个比较器对象
    */
    public void sort2(MyComparator comparator){
        //使用冒泡排序比较年龄 排ArrayList中的对象
        for (int i = 0; i < students.size(); i++) {
            for (int j = 0; j < students.size()-1; j++) {
                Student current = students.get(j);
                Student next = students.get(j + 1);
                int result=comparator.compare(current,next);
                //要实现排序 if 这儿的boolean结果是个关键 而求boolean的这个过程不一定非要在自己类中实现
                if (result>0){
                    Student temp = current;
                    students.set(j,next);
                    students.set(j+1,temp);
                }
            }
        }
    }

    public ArrayList<Student> getStudents() {
        return students;
    }
    public void setStudents(ArrayList<Student> students) {
        this.students = students;
    }
}

4.定义对象的类

package Test.treeSetDemo;

class Student implements MyComparable<Student>{
    private String name;
    private int age;
    private int height;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }

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

    @Override
    public int compareTo(Student o) {
        int result=this.age -o .age;
        return result;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

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

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

5.测试

package Test.treeSetDemo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        ArrayList<Student> students = myArray.getStudents();
        students.add(new Student("aaa", 111,175));
        students.add(new Student("bbb", 102,180));
        students.add(new Student("ccc", 195,182));
        students.add(new Student("ddd", 333,179));
        students.add(new Student("eee", 111,180));
        // 1.直接排序 实现对象的排序
           myArray.sort();
        for (Student student : students) {
            System.out.println(student);
        }
        System.out.println("------------------------------------");
        // 2.让对象可比 即对象实现comparable
        myArray.sort2();
        for (Student student : students) {
            System.out.println(student);
        }
        System.out.println("------------------------------------");
        //3.传入一个比较器对象
        myArray.sort2(new MyComparator() {
            @Override
            public int compare(Student student1, Student student2) {
                int result=student1.getHeight()-student2.getHeight();//先比身高 升序
                result= result==0?student2.getAge()-student1.getAge():result;//后比年龄 降序
                return result;
            }
        });
        for (Student student : students) {
            System.out.println(student);
        }
    }
}