简单排序和冒泡排序（二）

一、简单排序

在我们的程序中，排序是非常常见的一种需求，提供一些数据元素，把这些数据元素按照一定的规则进行排序，比如查询一些商品，按照商品的价格进行排序，再比如比较学生，按照学生的年龄进行排序等等。

1.1、Comparable 接口介绍

1）、Comparable 是 Java 给我们提供的一个用于定义排序规则的接口。

2）、Comparable接口中只有一个方法：punblic int comparTo(Object obj) ，obj 为要比较的对象。

3）、compareTo 方法中，将当前对象和 obj 这个对象进行比较，如果大于返回 1，等于返回 0，小于返回 -1，(此处的 1 也可以是正整数，-1 也可以是负整数）。

1.2、实际案例

在这里我们以案例的形式进行一个简单的实践：

1、定义一个学生类 Student ，他有年龄 age 和姓名 username 两个属性，并通过 Comparable 接口提供比较规则。

2、定义一个测试类 Test，在测试类中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试

//1、定义学生类
class Student implements Comparable<Student>{
    private String username;
    private int age;

    public String getUsername(){
        return username;
    }

    public void setUsername(String username){
        this.username = username;
    }

    public int getAge(){
        return age;
    }

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

    @Override
    public String toString(){
        return "Student{username=" + username + ",age=" + age + "}";
    }

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

//2、定义测试类并进行测试
public class Test {

    public static Comparable getMax(Comparable c1,Comparable c2){
        int result = c1.compareTo(c2);
        if(result >= 0){
            return c1;
        }else{
            return c2;
        }
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setUsername("张三");
        s1.setAge(18);

        Student s2 = new Student();
        s2.setUsername("李四");
        s2.setAge(20);

        final Comparable max = getMax(s1, s2);
        System.out.println(max);
    }
}

//打印结果
Student{username=李四,age=20}

上述代码我们使用 Comparable 接口定义了学生的比较规则，获取年龄较大的学生

二、冒泡排序

1）、冒泡排序（Bubble Sort）是计算机科学领域一种较为简单的排序算法

2）、冒泡排序的原理：

1、比较相邻的元素，如果前一个元素比后一个元素大，就交换这两个元素的位置。

2、对每一个相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素，最终最后位置的元素就是最大值。

如下图：

实际案例：

排序前：{4,5,6,3,2,1}

排序后：{1,2,3,4,5,6}

我们使用冒泡排序实现一下：

//1、编写一个冒泡排序的类
class Bubble{
    
    public static void sort(Comparable[] a){
        final int length = a.length;
        //外层循环需要执行 length - 1 次
        for (int i = length - 1; i > 0; i--){
            //外层循环每执行一次，内层循环需执行 i 次比较来将最大数放到最后面
            for(int j = 0; j < i; j++){
                //如果前一个数大于后一个数，则进行交换
                if(greater(a[j],a[j+1])){
                    exchange(a,j,j+1);
                }
            }
        }
    }

    /**
     * 比较两个数的大小
     */
    public static boolean greater(Comparable c1,Comparable c2){
        return c1.compareTo(c2) > 0;
    }

    /**
     * 交换 i，j 位置的值
     */
    public static void exchange(Comparable[] a,int i,int j){
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

//2、测试
public class Test {

    public static void main(String[] args) {
       Integer[] intArray = {4,5,6,3,2,1};
       Bubble.sort(intArray);
       System.out.println(Arrays.toString(intArray));
    }
}

//打印结果
[1, 2, 3, 4, 5, 6]

三、总结

本篇文章我们介绍了：

1、Comparable 接口：主要用于定义排序的规则。并编写了实际案例

2、介绍了冒泡排序的原理，并使用冒泡排序算法对我们的数组进行从小到大的升序排序

好了，本篇文章到这里就结束了，感谢你的阅读🤝