我已经多次发现这个问题了,我已经尝试了所有的解决方案,当我提交它们时,我的代码因“空指针异常”而失败
/**
* q5: Create a public class named "Fleet" with private instance variables "considerable" and
* "complicated" each of type int. You may add any other methods and variables you'd like to
* this class.
*
* Outside of Fleet (in the Problem Set class) write a public static method named "sortFleet"
* that takes an ArrayList of Fleets as a parameter and returns void. This method will sort
* the input by the variable "complicated" in increasing order
*/
public class Fleet {
private int considerable, complicated;
public Fleet(int beginning) {
this.complicated = beginning;
}
public int getPrecious() {
return this.complicated;
}
@Override
public String toString() {
return "" + complicated;
}
}
public void sortFleet(ArrayList<Fleet> a) {
Collections.sort(a, new Comparator<Fleet>(){
@Override
public int compare(Fleet o1, Fleet o2) {
Long a1 = new Long(o1.getPrecious());
Long a2 = new Long(o2.getPrecious());
//return a1.compareTo(a2);
return Long.compare(a1,a2);
}
});
}
代码有效,我已经做了很多不同的方法,并且它有效。但是,当我提交它说同样的事情。每一次。请帮忙
答案 0 :(得分:0)
要通过复杂对Fleet进行排序,您必须使Object实现Comparable接口并覆盖compareTo()方法,如下所示。
public class Fleet implements java.lang.Comparable<Fleet>{
private int considerable, complicated;
public Fleet() {
super();
}
public Fleet(int considerable, int complicated) {
super();
this.considerable = considerable;
this.complicated = complicated;
}
public int getConsiderable() {
return considerable;
}
public void setConsiderable(int considerable) {
this.considerable = considerable;
}
public int getComplicated() {
return complicated;
}
public void setComplicated(int complicated) {
this.complicated = complicated;
}
@Override
public int compareTo(Fleet fleet) {
int compareComplicated = ((Fleet)fleet).getComplicated();
return this.complicated - compareComplicated;
}
@Override
public String toString() {
return "Fleet [considerable=" + considerable + ", complicated=" + complicated + "]";
}
}
现在我们可以在ArrayList上调用Collections.sort:
import java.util.ArrayList;
import java.util.Collections;
public class SortFleet {
public static void main(String[] args) {
ArrayList<Fleet> arrayFleet = new ArrayList<Fleet>();
Fleet fleetA = new Fleet(1, 2);
Fleet fleetB = new Fleet(4, 12);
Fleet fleetC = new Fleet(3, 5);
Fleet fleetD = new Fleet(3, 50);
Fleet fleetE = new Fleet(2, 3);
Fleet fleetF = new Fleet(2, 50);
arrayFleet.add(fleetA);
arrayFleet.add(fleetB);
arrayFleet.add(fleetC);
arrayFleet.add(fleetD);
arrayFleet.add(fleetE);
arrayFleet.add(fleetF);
System.out.println("Before sort:");
for ( Fleet f : arrayFleet)
{
System.out.println(f);
}
System.out.println();
sortFleet(arrayFleet);
System.out.println("After sort:");
for ( Fleet f : arrayFleet)
{
System.out.println(f);
}
}
public static void sortFleet(ArrayList<Fleet> arrayFleet) {
Collections.sort(arrayFleet);
}
}
Before sort:
Fleet [considerable=1, complicated=2]
Fleet [considerable=4, complicated=12]
Fleet [considerable=3, complicated=5]
Fleet [considerable=3, complicated=50]
Fleet [considerable=2, complicated=3]
Fleet [considerable=2, complicated=50]
After sort:
Fleet [considerable=1, complicated=2]
Fleet [considerable=2, complicated=3]
Fleet [considerable=3, complicated=5]
Fleet [considerable=4, complicated=12]
Fleet [considerable=3, complicated=50]
Fleet [considerable=2, complicated=50]
删除可比较的接口和Fleet类中的覆盖,你可以这样排序,返回相同的预期输出:
public static void sortFleet(ArrayList<Fleet> arrayFleet) {
Collections.sort(arrayFleet, Comparator.comparingInt(Fleet::getComplicated));
}