Java自定义对象数组实现冒泡排序和二分法查找

自定义对象数组实现冒泡排序

排序算法多种多样，今天只玩冒泡排序，不用基本数据类型了，用自定义对象类型创建数组并实现冒泡排序

1. 先创建自定义实体对象 Student

   import java.io.Serializable;
   import java.util.Objects;
   
   public class Student implements Serializable, Comparable {
       
       private static final long serialVersionUID = -6426911555504380355L;
   
       private int id;         // 学号
       private String name;    // 姓名
       private int age;        // 年龄
       private int math;       // 数学成绩
       private int eng;        // 英语成绩
       private int chin;       // 语文成绩
       
       // 省略无参，有参，get()，set()，toString()方法
       
       // 重写 equals 比较策略
       @Override
       public boolean equals(Object o) {
           if (this == o) return true;
           if (o == null || getClass() != o.getClass()) return false;
           Student student = (Student) o;
           return id == student.id;
       }
   	// 以及重写 hashCode 保持一致性
       @Override
       public int hashCode() {
           return Objects.hash(id);
       }
       
       // 实现比较规则
       @Override
       public int compareTo(Student o) {
   
           // 考试成绩排名 总分高的在前 总分相等的 比较 语文 数学 英语 的单科分数 来决定 排名先后
   
           // 判断是否是一个对象地址
           if (this == o) {
               return 0;
           }
   
           // 调用者的总成绩
           int a = this.chin + this.math + this.eng;
   
           // 比较者的总成绩
           int b = o.chin + o.math + o.eng;
   
           // 比较总成绩
           if (a > b) {
               return 1;
           }
           if (a < b) {
               return -1;
           }
           // 总成绩的相等时
           if (a == b) {
               // 比较语文
               if (this.chin > o.chin) {
                   return 1;
               }
               if (this.chin < o.chin) {
                   return -1;
               }
               if (this.chin == o.chin) {
                   // 比较数学
                   if (this.math > o.math) {
                       return 1;
                   }
                   if (this.math < o.math) {
                       return -1;
                   }
                   if (this.math == o.math) {
                       // 比较英语
                       if (this.eng > o.eng) {
                           return 1;
                       }
                       if (this.eng < o.eng) {
                           return -1;
                       }
                   }
               }
           }
   		
           return 0;
       }
       
   }
   

   2. 开始冒泡

      // 先准备学生数据
      Student[] students = {
          new Student(1001, "小一", 18, 75, 65, 89),
          new Student(1002, "小二", 18, 15, 23, 55),
          new Student(1004, "小四", 19, 95, 90, 100),
          new Student(1005, "小五", 18, 45, 75, 68),
          new Student(1006, "小六", 20, 10, 15, 35),
          new Student(1007, "小七", 18, 75, 58, 68),
      };
      
      // 打印初始数据
      for (Student student : students) {
          System.out.println("student before = " + student);
      }
      
      // 使用 Arrays 工具类实现排序
      Arrays.sort(students);
      
      // 打印排序后的数据
      for (Student student : students) {
          System.out.println("student after = " + student);
      }
      

      自定义冒泡排序方法

      public static void bubbleSort(Student[] students) {
      
          // 临时交换对象
          Student temp = null;
          
          for (int i = 0; i < students.length; i++) {
      
              // 标记经过一轮循环是否进行了交换
              boolean flag = true;
      
              for (int j = 0; j < students.length - i - 1; j++) {
      
                  // 通过Student实体自定义重写的compareTo方法进行比较
                  if ((students[j].compareTo(students[j + 1])) > 0) {
                      
                      temp = students[j];
                      students[j] = students[j + 1];
                      students[j + 1] = temp;
                      // 打上交换的标记
                      flag = false;
                  }
              }
      
              // 根据标记判断是否已经完成排序
              if (flag) {
                  break;
              }
              // 打印冒泡排序的次数
              System.out.println((i + 1) + "趟排序");
          }
      }
      

      调用自定义冒泡排序

      // 调用静态方法
      类名.bubbleSort(studentsCopy);
      
      // 遍历排序后的数组信息
      for (Student student : studentsCopy) {
          System.out.println("bubbleSort student = " + student);
      }
      

自定义对象数组实现二分法查找

// 自定义二分查找方法
public static int MyBinarySearch(Student[] students, Student student) {

    // 标记数组的最低位和最高位
    int lowIndex = 0;
    int highIndex = students.length - 1;

    // 进入循环的必要条件
    while (lowIndex <= highIndex) {

        // 二分取中间索引
        int middleIndex = (lowIndex + highIndex) / 2;

        // 判断两个学生的学号是否相等 student 已经重写了 equals 方法
        if (students[middleIndex].equals(student)) {
            return middleIndex;
        }

        // 如果中间学生的学号 大于 寻找学生的学号 那判断 数组中间 前半段的数据即可
        if (students[middleIndex].getId() > student.getId()) {

            highIndex = middleIndex - 1;
        }

        // 如果中间学生的学号 小于 寻找学生的学号 那判断 数组中间 后半段的数据即可
        if (students[middleIndex].getId() < student.getId()) {
            lowIndex = middleIndex + 1;
        }
    }

    // 返回负数代表没有找到
    return -1;
}

调用自定义二分查找法

int binarySearchIndex = StudentArraysTest.MyBinarySearch(studentsCopy, new Student(1005, "小五", 18));

System.out.println("binarySearchIndex = " + binarySearchIndex);

// 通过查询到的下标打印学生的信息
if (binarySearchIndex >= 0 && binarySearchIndex < studentsCopy.length) {

    System.out.println(studentsCopy[binarySearchIndex]);
} else {

    System.out.println("没有找到该学生的信息");
}