java - 按对象之一对数组列表中的对象进行排序

Question

我已经多次发现这个问题，我已经尝试了他们所有的解决方案，当我提交它们时，我的代码因“空指针异常”而失败

   /**
 * 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);

    }

}); 
 }

该代码有效，我已经做了很多不同的方法并且它有效。但是当我提交时，它说了同样的话。每一次。请帮忙

标签： javasortingnullpointerexception

Answer 1

要按 Complicated 对 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]

编辑：Java 8 方法：

删除 Fleet 类中的 Comparable 接口和覆盖，您可以像这样排序，返回相同的预期输出：

public static void sortFleet(ArrayList<Fleet> arrayFleet) {
        Collections.sort(arrayFleet, Comparator.comparingInt(Fleet::getComplicated));
}