Java 我正在尝试编写一个包含升序和降序选项的选择排序

我有一个选择排序方法来按年份变量对对象进行排序。我让它按升序排序，我似乎无法按降序排序。如果有人能看一下代码，并可能为我指出正确的方向，那就太棒了

public static void sortYears(ArrayList<Movies3> list, int ad){
    int max, min,  i, j;
    Movies3 temp;

    if(ad == 1){
        for (i = 0; i < list.size() - 1; i++){
            max = i;

            for (j = i + 1; j < list.size(); j++){
                if (list.get(max).getYear() > list.get(j).getYear()){
                    max = j;
                }
            }

            temp = list.get(i);
            list.set(i, list.get(max));
            list.set(max, temp);
        }
    }else if(ad == 2){
        for (i = 0; i < list.size() - 1; i++){
            min = i;

            for (j = i + 1; j > list.size(); j++){
                if (list.get(min).getYear() < list.get(j).getYear()){
                    min = j;
                }
            }

            temp = list.get(i);
            list.set(i, list.get(min));
            list.set(min, temp);
        }
    }
}

publicstaticvoidsortyears（数组列表，int-ad）{
int max，min，i，j；
电影3；
如果（ad==1）{
对于（i=0；ilist.get（j）.getYear（））{
max=j；
}
}
temp=列表获取（i）；
list.set（i，list.get（max））；
列表设置（最大值、温度）；
}
}否则如果（ad==2）{
对于（i=0；ilist.size（）；j++）{
if（list.get（min.getYear（）

用于（j=i+1；j>list.size（）；j++）{

---

谓词应该是

j

而不是

，否则您的循环将永远不会以

i+1

的形式迭代，始终

用：
comparator.comparator.compare（list.get（max.getYear（），list.get（j.getYear（））>0替换直接比较，如
list.get（max.getYear（））>list.get（j.getYear（））>0

然后，您可以使用
您的变量名和作用域非常混乱，有很多重复的代码

for（j=i+1；j>list.size（）；j++）
-这行代码在大多数情况下永远不会执行

这是对降序的修复：

// the same walk as for ASC but reversed comparison
for (int i = 0; i < list.size() - 1; i++) {
    candidateIndex = i;

    for (int j = i + 1; j < list.size(); j++) {
        if (list.get(candidateIndex).getYear() < list.get(j).getYear()) {
            candidateIndex = j;
        }
    }

    temp = list.get(i);
    list.set(i, list.get(candidateIndex));
    list.set(candidateIndex, temp);
}

您还可以让您的类实现为它定义自然顺序，并使用它而不是
Comparator
我建议您的类Movies3必须实现接口Comparable和使用java类列表的排序方法和创建自定义比较器他用更好更优雅的方式做这件事

可能是这样的：

对于电影3类

public class Movie3 implements Comparable<Movie3> {


private int year;
    private String author;
    private String genre;
    public Movie3(int year, String author, String genre) {
        super();
        this.year = year;
        this.author = author;
        this.genre = genre;
    }
    /**
     * @return the year
     */
    public int getYear() {
        return year;
    }
    /**
     * @param year the year to set
     */
    public void setYear(int year) {
        this.year = year;
    }
    /**
     * @return the author
     */
    public String getAuthor() {
        return author;
    }
    /**
     * @param author the author to set
     */
    public void setAuthor(String author) {
        this.author = author;
    }
    /**
     * @return the genre
     */
    public String getGenre() {
        return genre;
    }
    /**
     * @param genre the genre to set
     */
    public void setGenre(String genre) {
        this.genre = genre;
    }

    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("Year: "+this.getYear());
        sb.append("Author: "+this.getAuthor());
        sb.append("Genre: "+this.getGenre());
        return sb.toString();
    }
    public int compareTo(Movie3 m) {
        return Integer.compare(this.year, m.year);
    }

}

公共级电影3实现可比性{
私人国际年；
私有字符串作者；
私人弦乐体裁；
公共电影3（整年，弦乐作者，弦乐类型）{
超级（）；
今年=年；
this.author=作者；
这个。流派=流派；
}
/**
*@return the year
*/
公共int getYear（）{
回归年；
}
/**
*@param year设置的年份
*/
公共年（国际年）{
今年=年；
}
/**
*@返回作者
*/
公共字符串getAuthor（）{
返回作者；
}
/**
*@param author要设置的作者
*/
公共void setAuthor（字符串编写器）{
this.author=作者；
}
/**
*@返回流派
*/
公共字符串getgreen（）{
回归体裁；
}
/**
*@param-genre要设置的流派
*/
公共类型（字符串类型）{
这个。流派=流派；
}
公共字符串toString（）{
StringBuilder sb=新的StringBuilder（）；
某人加上（“年：+this.getYear（））；
sb.append（“作者：+this.getAuthor（））；
sb.append（“流派：+this.getgreen（））；
使某人返回字符串（）；
}
公共国际比较（电影3M）{
返回整数。比较（this.year，m.year）；
}
}

另一方面，自定义比较器是：

import java.util.Comparator;

public class MovieYearComparator implements Comparator<Movie3> {
    private boolean reverse;

    public MovieYearComparator(boolean reverse) {
        super();
        this.reverse = reverse;
    }

    @Override
    public int compare(Movie3 m1, Movie3 m2) 
    {
        if (reverse)
            return m1.getYear() < m2.getYear() ? 1 : m1.getYear() == m2.getYear() ? 0 : -1;
        else
            return m1.getYear() < m2.getYear() ? -1 : m1.getYear() == m2.getYear() ? 0 : 1;
    }
}

import java.util.Comparator；
公共类MovieYearComparator实现了Comparator{
私有布尔逆；
public MovieYearComparator（布尔反向）{
超级（）；
这个。反向=反向；
}
@凌驾
公共整数比较（电影3 m1，电影3 m2）
{
如果（反向）
返回m1.getYear（）

最后是测试：

import java.util.ArrayList;
import java.util.List;

import data.Movie3;
import data.MovieYearComparator;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Movie3> movies = new ArrayList<Movie3>();
        movies.add(new Movie3(1000,"sds","sdf"));
        movies.add(new Movie3(1001,"sds","sdf"));
        movies.add(new Movie3(2001,"sds","sdf"));
        movies.add(new Movie3(2444,"sds","sdf"));
        movies.add(new Movie3(1002,"sds","sdf"));
        movies.add(new Movie3(1003,"sds","sdf"));
        System.out.println(movies.toString());
        boolean reverse = true;
        movies.sort(new MovieYearComparator(!reverse));
        System.out.println(movies.toString());
        movies.sort(new MovieYearComparator(reverse));
        System.out.println(movies.toString());  

    }
}

import java.util.ArrayList；
导入java.util.List；
导入数据。电影3；
导入data.MovieYearComparator；
公开课考试{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
列表电影=新建ArrayList（）；
新增（新电影3（1000，“sds”、“sdf”）；
新增（新电影3（1001，“sds”、“sdf”）；
新增（新电影3（2001年，“sds”、“sdf”）；
新增(新电影3(2444,sds,sdf);；
新增（新电影3（1002，“sds”、“sdf”）；
新增（新电影3（1003，“sds”、“sdf”）；
System.out.println（movies.toString（））；
布尔反向=真；
电影。排序（新电影年比较器（！反向））；
System.out.println（movies.toString（））；
电影。排序（新电影年比较器（反向））；
System.out.println（movies.toString（））；
}
}
AD变量为升序或降序，在您使用的第二条if语句中，1=升序，2=降序（j=i+1；j>list.size（）；j++）
这一行单独计算结果将为
false
，因为在大多数情况下，j很可能小于列表的大小，因此整个循环不会执行。为什么不使用Comparator？您可以使用
Comparator.reverseOrder（）而不是传递
reverse
标志
谢谢Ruslan。我在java类列表中寻找类似的东西。
import java.util.Comparator;

public class MovieYearComparator implements Comparator<Movie3> {
    private boolean reverse;

    public MovieYearComparator(boolean reverse) {
        super();
        this.reverse = reverse;
    }

    @Override
    public int compare(Movie3 m1, Movie3 m2) 
    {
        if (reverse)
            return m1.getYear() < m2.getYear() ? 1 : m1.getYear() == m2.getYear() ? 0 : -1;
        else
            return m1.getYear() < m2.getYear() ? -1 : m1.getYear() == m2.getYear() ? 0 : 1;
    }
}

import java.util.ArrayList;
import java.util.List;

import data.Movie3;
import data.MovieYearComparator;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Movie3> movies = new ArrayList<Movie3>();
        movies.add(new Movie3(1000,"sds","sdf"));
        movies.add(new Movie3(1001,"sds","sdf"));
        movies.add(new Movie3(2001,"sds","sdf"));
        movies.add(new Movie3(2444,"sds","sdf"));
        movies.add(new Movie3(1002,"sds","sdf"));
        movies.add(new Movie3(1003,"sds","sdf"));
        System.out.println(movies.toString());
        boolean reverse = true;
        movies.sort(new MovieYearComparator(!reverse));
        System.out.println(movies.toString());
        movies.sort(new MovieYearComparator(reverse));
        System.out.println(movies.toString());  

    }
}