使用Comparable查找最大值/最小值

Question

我有一個對象類

public class Film implements Comparable<Film>

我正在使用Eclipse，想知道為什么Film用紅色加下划線並顯示錯誤：

The type Film must implement the inherited abstract method Comparable<Film>.compareTo<Film>

現在是我的主要問題：

如何獲得用戶提交的最大/最小電影長度和標題？

我的對象類Film具有用於電影標題和電影長度的getter和setter方法以及toString方法。 下面這個文章（＃3）我創建了我的對象類的兩個方法：

public int max(Film maxLength){
    int compareLength = ((Film) maxLength).getLength();

    return this.length - compareLength;
}

public int min(Film minLength){
    int compareLength = ((Film) minLength).getLength();

    return compareLength - this.length;
}

我可以使用這些來查找和打印用戶提交的膠卷長度的最大值/最小值嗎？

如果是這樣，怎么辦？

如果沒有，這樣做的正確方法是什么？

測試類如下：

import java.util.Scanner;
public class test {
    public static void main (String[] args){
        Film[] f = new Film[3];
        Scanner input = new Scanner(System.in);
        for (int i=0;i<3;i++){
            f[i] = new Film(); 

            System.out.println("Enter Film Length:");
            f[i].setLength(input.nextInt());
            input.nextLine();
            System.out.println("Enter Title:");
            f[i].setTitle(input.nextLine());
        }
        input.close();
        for (int i = 0; i < 3; i++) {
            System.out.println(f[i].toString());
        }
    }
}

Answer 1

Film類實現Comparable<Film> 。 這意味着您必須在Film類中實現一個稱為compareTo()的方法，該方法將為此類的對象提供排序。

@Override
public int compareTo(Film that) {
    // Order by film length
    return Integer.compare(this.length, that.length);
}

如果只需要按膠片長度對對象進行排序，則可以使用Arrays.sort() ：

Film[] films = new Film[3];
// put the objects into the array
Arrays.sort(films);

然后films[0]將包含長度最短的電影，而最后一個元素將是長度最長的電影。

如果需要按其他字段（例如電影標題）進行比較，則可以創建一個自定義比較器：

class FilmTitleComparator implements Comparator<Film> {
    public int compare(Film a, Film b) {
        return Integer.compare(a.getTitle().length(), b.getTitle().length());
    }
}

並將其傳遞給Arrays.sort()

FilmTitleComparator titleComparator = new FilmTitleComparator();
Arrays.sort(films, titleComparator);

然后films[0]將包含標題最短的電影，而最后一個元素將是標題最長的電影。

Answer 2

為簡單起見，我對您的Film類進行了存根，以顯示有關如何實現Comparable的簡單示例

public class Film implements Comparable<Film> {
    int maxLength;
    int minLength;
    String title;

    public Film() {
         this.maxLength = 0;
         this.minLength = 0;
         this.title = "";
    }    

    // implement this method to accomplish comparison
    public int compareTo(Film f) {
        int result = 0; // the result to compute.

        if ( this.equals(f) ) {
            result = 0; // these objects are actually equal
        }

        // compare using meaningful data
        else if ( f != null) {
            // check to see if this film is greater than the specified film
            if ( this.getMaxLength() > f.getMaxLength() ) {
                // this film is comparatively greater, return > 0
                result = 1;
            }
            else if ( this.getMaxLength() == f.getMaxLength() ) {
                // these two films are comparatively equal
                result = 0;
            }
            else {
                // this film is comparatively less than the specified film
                result = -1;
            }

            // similarly, you could also check min, but there's really no reason to do that unless your implementation calls for it.
        }
        else {
            throw new IllegalArgumentException("null Film object not allowed here...");
        }

        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Film film = (Film) o;

        if (maxLength != film.maxLength) return false;
        if (minLength != film.minLength) return false;
        if (!title.equals(film.title)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = maxLength;
        result = 31 * result + minLength;
        result = 31 * result + title.hashCode();
        return result;
    }

    public int getMaxLength() {
        return maxLength;
    }

    public void setMaxLength(int maxLength) {
        this.maxLength = maxLength;
    }

    public int getMinLength() {
        return minLength;
    }

    public void setMinLength(int minLength) {
        this.minLength = minLength;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }    
}

要修復測試以實際使用這樣的實現（它實際上沒有測試任何東西……），您可以執行以下操作：

import java.util.Scanner;
public class test {
    public static void main (String[] args){
        Film lastFilm = null; // arbitrary reference to film
        Film[] f = new Film[3];
        Scanner input = new Scanner(System.in);
        for (int i=0;i<3;i++){
            f[i] = new Film(); 

            System.out.println("Enter Film Length:");
            f[i].setLength(input.nextInt());
            input.nextLine();
            System.out.println("Enter Title:");
            f[i].setTitle(input.nextLine());
        }
        input.close();
        for (int i = 0; i < 3; i++) {
            if ( lastFilm != null ) {
                 // compare the films to test. current to last film
                 if ( f[i].compareTo(lastFilm) > 0 ) {
                     System.out.println(f[i].getTitle() + " is greater than " + lastFilm.getTitle()");
                 }
                 else if ( f[i].compareTo(lastFilm) < 0 ) {
                     System.out.println(f[i].getTitle() + " is less than " + lastFilm.getTitle()");
                 }
                 else {
                     System.out.println(f[i].getTitle() + " is equal to " + lastFilm.getTitle()");
                 }
            }
            System.out.println(f[i].toString());
            lastFilm = f[i];
        }
    }
}

這樣的事情可以幫助您入門...祝您好運

Answer 3

另一個解決方案是實現Comparable<Film> ：

@Override
public int compareTo(Film that) {
   return this.length - that.length;
}

並使用org.apache.commons.lang3.ObjectUtils#min或org.apache.commons.lang3.ObjectUtils#max這樣：

Film min = ObjectUtils.min(film1, film2);
Film max = ObjectUtils.max(film1, film2);