new Comparator<Person>(){ @Override public int compare(Person p1, Person p2) { return p1. getAge () - p2. getAge() ;替换lambda表达式
时间: 2023-12-14 17:40:27 浏览: 29
使用lambda表达式替换上面的匿名内部类代码如下:
```
Comparator<Person> comparator = (p1, p2) -> p1.getAge() - p2.getAge();
```
相关问题
用Java编写在1.为Person类增加以下方法: (1)int getAge(int year) //返回在year年的年龄 (2)int getAge() //返回今年的年龄,重载 (3)int olderThen(Person per) //返回this与per //的年龄差值,按年龄比较对象大小 (4)boolean equals(Person per) //比较this与 // per引用实例对应成员变量值是否相等 2. 实现银行账户类构造方法成成员方法。 public class Account //账户类 { private String name; //储户姓名 private double balance; //账户余额 public Account(String name) //构造方法 public String getName() //返回账户名 public double balance() //查看账户余额 public boolean put(double value)//存款,存入金额 public double get(double value) //取款,参数为取款金额,返回实际取到金额 }的基础上,声明实现Comparble<T>接口,提供按照账户余额比较账户大小的方法;同时,使用Comparator<T>接口声明比较器类CompareName,按照账户名比较账户大小;编写main方法测试相应的接口实现方法。
下面是Java代码实现:
1. Person类:
```java
public class Person implements Comparable<Person> {
private String name;
private int birthYear;
public Person(String name, int birthYear) {
this.name = name;
this.birthYear = birthYear;
}
public int getAge(int year) {
return year - birthYear;
}
public int getAge() {
return getAge(Calendar.getInstance().get(Calendar.YEAR));
}
public int olderThan(Person per) {
return this.birthYear - per.birthYear;
}
public boolean equals(Person per) {
if (this == per) {
return true;
}
if (per == null) {
return false;
}
return this.name.equals(per.name) && this.birthYear == per.birthYear;
}
@Override
public int compareTo(Person per) {
return Integer.compare(this.birthYear, per.birthYear);
}
}
```
2. Account类:
```java
import java.util.Comparator;
public class Account implements Comparable<Account> {
private String name;
private double balance;
public Account(String name) {
this.name = name;
this.balance = 0;
}
public String getName() {
return name;
}
public double getBalance() {
return balance;
}
public boolean put(double value) {
if (value <= 0) {
return false;
}
balance += value;
return true;
}
public double get(double value) {
if (value <= 0 || balance < value) {
return 0;
}
balance -= value;
return value;
}
@Override
public int compareTo(Account acc) {
return Double.compare(this.balance, acc.balance);
}
public static class CompareName implements Comparator<Account> {
@Override
public int compare(Account acc1, Account acc2) {
return acc1.name.compareTo(acc2.name);
}
}
}
```
3. 测试代码:
```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 测试Person类
Person p1 = new Person("Tom", 1990);
Person p2 = new Person("Jerry", 1995);
System.out.println("Tom's age in 2021: " + p1.getAge(2021));
System.out.println("Jerry's age in 2021: " + p2.getAge(2021));
System.out.println("Tom's age: " + p1.getAge());
System.out.println("Jerry's age: " + p2.getAge());
System.out.println("Tom older than Jerry: " + p1.olderThan(p2));
System.out.println("Tom equals Jerry: " + p1.equals(p2));
// 测试Account类
List<Account> accounts = new ArrayList<>();
Account acc1 = new Account("Tom");
acc1.put(1000);
accounts.add(acc1);
Account acc2 = new Account("Jerry");
acc2.put(2000);
accounts.add(acc2);
Account acc3 = new Account("Alice");
acc3.put(1500);
accounts.add(acc3);
// 按照余额排序
System.out.println("Sort by balance:");
Collections.sort(accounts);
for (Account acc : accounts) {
System.out.println(acc.getName() + " " + acc.getBalance());
}
// 按照账户名排序
System.out.println("Sort by name:");
Collections.sort(accounts, new Account.CompareName());
for (Account acc : accounts) {
System.out.println(acc.getName() + " " + acc.getBalance());
}
}
}
```
java 中list<T>排序
Java中的List<T>可以使用Collections.sort()方法进行排序。
例如,如果我们有一个List<Integer>,我们可以按照以下方式对其进行排序:
```java
List<Integer> list = new ArrayList<>();
list.add(5);
list.add(2);
list.add(8);
list.add(1);
Collections.sort(list);
System.out.println(list); // 输出 [1, 2, 5, 8]
```
如果我们想要按照自定义的方式对List进行排序,我们可以使用Comparator接口。
例如,如果我们有一个List<Person>,我们可以按照Person对象的年龄字段进行排序:
```java
List<Person> list = new ArrayList<>();
list.add(new Person("Alice", 25));
list.add(new Person("Bob", 30));
list.add(new Person("Charlie", 20));
Collections.sort(list, new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
});
System.out.println(list); // 输出 [Charlie(20), Alice(25), Bob(30)]
```
在这个例子中,我们定义了一个Comparator<Person>对象,它比较两个Person对象的年龄字段。然后我们将这个Comparator对象传递给Collections.sort()方法,这样List就会按照我们定义的方式进行排序。