00013.04 常用接口 Comparator与Comparable练习

00013.04 常用接口 Comparator与Comparable练习

文章目录

• ​​00013.04 常用接口 Comparator与Comparable练习​​
• ​​一、思路是什么？​​

• ​​第一种方式​​
• ​​第二种方式​​

• ​​二、实现步骤​​

• ​​1.代码如下​​

• ​​总结​​

# 前言 **题目如下** 接口的练习 （1）声明一个员工类Employee，有属性：编号、姓名、年龄、薪资 （2）让Employee员工类实现java.lang.Comparable接口， 重写抽象方法，按照编号从小到大排序 （3）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果 （4）声明SalaryComparator类，实现java.util.Comparator接口， 重写抽象方法，按照薪资从高到低排序 用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果

一、思路是什么？

第一种方式

第二种方式

因为如果按照上面的代码一步一步走，我们的自然排序只能按照编号排序，现在我们不想这样了

加个类

调用：

二、实现步骤

最终效果

代码如下（示例）：

1.代码如下

TestExer2_Comparator与Comparable练习类：

package com.atguigu.test06;

import java.util.Arrays;

/*
 * 接口的练习2题目：
（1）声明一个员工类Employee，有属性：编号、姓名、年龄、薪资
（2）让Employee员工类实现java.lang.Comparable接口，
    重写抽象方法，按照编号从小到大排序
（3）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果
（4）声明SalaryComparator类，实现java.util.Comparator接口，
    重写抽象方法，按照薪资从高到低排序
  用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果
 */
public class TestExer2_Comparator与Comparable练习 {
  public static void main(String[] args) {
    //（2）让Employee员工类实现java.lang.Comparable接口，
    Employee employee = new Employee();
    //（3_2）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果
    Employee [] all=new Employee[5];
    all[0]=new Employee(1,"一",20,2700);
    all[1]=new Employee(5,"五",25,6500);
    all[2]=new Employee(2,"二",19,3000);
    all[3]=new Employee(3,"三",22,2000);
    all[4]=new Employee(4,"四",26,8000);
    Arrays.sort(all);
    //遍历看下效果
    for (int i = 0; i < all.length; i++) {
      System.out.println(all[i]);
    }
    System.out.println("------------------");
/*    （4）声明SalaryComparator类，实现java.util.Comparator接口，
    重写抽象方法，按照薪资从高到低排序
  用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果*/
    Arrays.sort(all,new SalaryComparator());
    for (int i = 0; i < all.length; i++) {
      System.out.println(all[i]);
    }
  }
}

Employee类：

package com.atguigu.test06;
//（1）声明一个员工类Employee，有属性：编号、姓名、年龄、薪资
public class Employee implements Comparable {
  //属性
  private int id;
  private String name;
  private int age;
  private double salary;
  //构造器
  public Employee() {
    super();
  }
  public Employee(int id, String name, int age, double salary) {
    super();
    this.id = id;
    this.name = name;
    this.age = age;
    this.salary = salary;
  }
  //get/set
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  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 double getSalary() {
    return salary;
  }
  public void setSalary(double salary) {
    this.salary = salary;
  }
  @Override
  public String toString() {
    return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
  }
  //（3_1）在测试类中创建Employee[]数组，调用java.util.Arrays的sort方法进行排序，遍历结果
  @Override
  public int compareTo(Object o) {
    
    Employee e=(Employee)o;
    if (this.id>e.id) {
      return 1;
    }
    else if(this.id<e.id){
      return -1;
    }
    else{
      return 0;
    }
  }
  
  
}

SalaryComparator类：

/*  （4）声明SalaryComparator类，实现java.util.Comparator接口，
重写抽象方法，按照薪资从高到低排序,用SalaryComparator对象重新对Employee[]数组进行排序，遍历结果*/
package com.atguigu.test06;

import java.util.Comparator;

public class SalaryComparator implements Comparator {

  @Override
  public int compare(Object o1, Object o2) {
    Employee e1=(Employee)o1;
    Employee e2=(Employee)o2;
    
    
    if (e1.getSalary()>e2.getSalary()) {
      //return 1;//升序 从小到大
      return -1;
    }
    else if (e1.getSalary()>e2.getSalary()) {
      return 1;
    }
    else{
      return 0;
    }
  }
}

总结

娃哈哈，暂时没有啥好总结的，自己意淫吧。