Java 通过对象（歌曲）的阵列列表进行排序

所以基本上，这是一个项目，我们得到一个文本文件，其中包含一长串的歌曲。使用这个文件，我们应该制作歌曲对象，并且能够按照艺术家、等级、年份和标题进行排序和过滤。到目前为止，我的大部分工作正常。我唯一需要帮助的就是分类。过滤方法似乎在工作，但排序没有（过滤和排序方法在SongCollection类中）。我们应该在其中一种排序方法中使用插入排序，但它似乎不起作用

客户端类：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Scanner;

public class GazillionSongs {
    public static void main(String[] args){
        try {
            //Prompt user to enter a file
            System.out.println("This will filter and sort songs.");
            Scanner input = new Scanner(System.in);
            //Stores file in arraylist
            Scanner f = new Scanner(new File("agazillionsongs.txt"));
            //makes array of songs
            ArrayList<Song> list = new ArrayList<Song>();
            //songcollection object
            SongCollection songs = new SongCollection(list);
            //stores songs in arraylist
            while (f.hasNextLine()) {
                Song song = new Song();
                song.parse(f.nextLine());
                list.add(song); 
            }
            //Filters
            System.out.println("Choose a filter. Year, rank, artist, or title?");
            String userInput = input.nextLine();
            //filters By year
            if (userInput.equals("year")){
                System.out.println("Enter a year or range:");
                String year = input.nextLine();
                songs.filterYear(Range.parse(year));
                songs.print();
                //filters by rank   
            } else if(userInput.equals("rank")) {
                System.out.println("Enter a rank or range:");
                String rank = input.nextLine();
                songs.filterRank(Range.parse(rank));
                songs.print();
                //filters by artist 
            } else if(userInput.equals("artist")) {
                System.out.println("Enter an artist");
                String artist = input.nextLine();
                songs.filterArtist(artist);
                songs.print();
                //filters by title  
            } else if(userInput.equals("title")) {
                System.out.println("Enter a title");
                String title = input.nextLine();
                songs.filterTitle(title);
                songs.print();
            } else if(userInput.equals("year and rank")) {
                System.out.println("Enter a year and rank");
                String year = input.next();
                String and = input.next();
                String rank = input.next();
                songs.filterYear(Range.parse(year));
                songs.filterRank(Range.parse(rank));
                songs.print();
            } else if(userInput.equals("artist and title")) {
                System.out.println("Enter artist and title");
                String artist = input.next();
                String and = input.next();
                String title = input.next();
                songs.filterArtist(artist);
                songs.filterTitle(title);
                songs.print();
            } else if(userInput.equals("year and title")) {
                System.out.println("Enter year and title");
                String year = input.next();
                String and = input.next();
                String title = input.next();
                songs.filterYear(Range.parse(year));
                songs.filterTitle(title);
                songs.print();
            } else if(userInput.equals("year and artist")) {
                System.out.println("Enter year and artist");
                String year = input.next();
                String and = input.next();
                String artist = input.next();
                songs.filterYear(Range.parse(year));
                songs.filterArtist(artist);
                songs.print();
            }
            //sorting
            System.out.println("Sort by what?");
            String sortInput = input.next();
            if(sortInput.equals("year")) {
                songs.sortY();
                songs.print();
            } else if (sortInput.equals("rank")) {
                songs.sortR();
                songs.print();
            } else if (sortInput.equals("artist")) {
                songs.sortA();
                songs.print();
            } else if (sortInput.equals("title")) {
                songs.sortT();
                songs.print();
            }
            //file not found
        } catch (FileNotFoundException e) { 
            System.out.println("File not found"); 
        }
    }
}

歌曲精选班：

import java.util.ArrayList;
import java.util.Collections;

public class SongCollection {
    //arraylist
    public ArrayList<Song> list;
    //constructor
    public SongCollection(ArrayList<Song> songs) {
        list = songs;
    }
    //filters by year
    public void filterYear(Range r) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!r.contains(list.get(i).getYear())) {
                list.remove(i);
            }
        }
    }
    //filters by rank
    public void filterRank(Range r) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!r.contains(list.get(i).getRank())) {
                list.remove(i);
            }
        }
    }
    //filters by artist
    public void filterArtist(String s) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!list.get(i).getArtist().contains(s)) {
                list.remove(i);
            }
        }
    }
    //filters by title
    public void filterTitle(String s) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!list.get(i).getTitle().contains(s)) {
                list.remove(i);
            }
        }
    }
    //sorts by year
    public void sortYear(Song[] song){
        int in, out;

        for (out = 1; out < song.length; out++) {
            Song temp = song[out];
            in = out;

            while (in > 0 && song[in - 1].getYear() > 0) {
                song[in] = song[in - 1];
                --in;
            }
            song[in] = temp;
        }
    }
    //sorts by rank
    public void sortRank(Song[] song) {
        //insertion sort
        int in, out;

        for (out = 1; out < song.length; out++) {
            Song temp = song[out];
            in = out;

            while (in > 0 && song[in - 1].getRank() > 0) {
                song[in] = song[in - 1];
                --in;
            }
            song[in] = temp;
        }
    }
    //sorts by artist
    public void sortArtist(Song[] song) {
        //insertion sort
        int in, out;

        for (out = 1; out < song.length; out++) {
            Song temp = song[out];
            in = out;

            while (in > 0 && song[in - 1].getArtist().compareTo(temp.getArtist()) > 0) {
                song[in] = song[in - 1];
                --in;
            }
            song[in] = temp;
        }
    }
    //sort by title
    public void sortTitle(Song[] song) {
        //insertion sort
        int in, out;

        for (out = 1; out < song.length; out++) {
            Song temp = song[out];
            in = out;

            while (in > 0 && song[in - 1].getTitle().compareTo(temp.getTitle()) > 0) {
                song[in] = song[in - 1];
                --in;
            }
            song[in] = temp;
        }
    }
    // prints the songs
    public void print() {
        for (int i = 0; i < list.size(); i++) {
            Song song = list.get(i);
            System.out.print(song.toString());
        }
    }
    public void sortY() {
        Song[] arr = list.toArray(new Song[list.size()]);
        sortYear(arr);
    }
    public void sortR() {
        Song[] arr = list.toArray(new Song[list.size()]);
        sortRank(arr);
    }
    public void sortA() {
        Song[] arr = list.toArray(new Song[list.size()]);
        sortArtist(arr);
    }
    public void sortT() {
        Song[] arr = list.toArray(new Song[list.size()]);
        sortTitle(arr);
    }
}

import java.util.ArrayList；
导入java.util.Collections；
公营歌曲集{
//arraylist
公共阵列列表；
//建造师
公共歌曲集（ArrayList歌曲）{
列表=歌曲；
}
//按年筛选
公共空过滤器耳（范围r）{
对于（int i=list.size（）-1；i>=0；i--）{
如果（！r.contains（list.get（i）.getYear（））{
列表。删除（i）；
}
}
}
//按等级筛选
公共空过滤器（范围r）{
对于（int i=list.size（）-1；i>=0；i--）{
如果（！r.contains（list.get（i）.getRank（））{
列表。删除（i）；
}
}
}
//按艺术家筛选
public void filterArtist（字符串s）{
对于（int i=list.size（）-1；i>=0；i--）{
如果（！list.get（i）.getArtister（）包含个）{
列表。删除（i）；
}
}
}
//按标题筛选
公共无效筛选器文件（字符串s）{
对于（int i=list.size（）-1；i>=0；i--）{
如果（！list.get（i）.getTitle（）包含（s））{
列表。删除（i）；
}
}
}
//按年分类
公共空座位（歌曲[]歌曲）{
int-in，out；
for（out=1；out0&&song[in-1].getYear（）>0）{
宋[in]=宋[in-1]；
--在；
}
宋[英]=临时工；
}
}
//按等级分类
公共空间sortRank（歌曲[]歌曲）{
//插入排序
int-in，out；
for（out=1；out0&&song[in-1].getRank（）>0）{
宋[in]=宋[in-1]；
--在；
}
宋[英]=临时工；
}
}
//按艺术家分类
公共虚空巫师（歌曲[]歌曲）{
//插入排序
int-in，out；
for（out=1；out0&&song[in-1].getArtist（）.compareTo（temp.getArtist（））>0）{
宋[in]=宋[in-1]；
--在；
}
宋[英]=临时工；
}
}
//按标题排序
公共空间Sortittle（歌曲[]歌曲）{
//插入排序
int-in，out；
for（out=1；out0&&song[in-1].getTitle（）.compareTo（temp.getTitle（））>0）{
宋[in]=宋[in-1]；
--在；
}
宋[英]=临时工；
}
}
//打印歌曲
公开作废印刷品（）{
对于（int i=0；i

射程等级：

import java.util.StringTokenizer;

public class Range {
    public static int min;
    public static int max;
    public static String str;

    public Range(String s){
        str = s;
    }
    public static Range parse(String s){
        //range
        if (s.contains("-")){
            StringTokenizer parse = new StringTokenizer(s, "-");
            String strMin = parse.nextToken();
            min = Integer.parseInt(strMin);
            String strMax = parse.nextToken();
            max = Integer.parseInt(strMax);

        }else{
            min = Integer.parseInt(s);
            max = min;
        }
        Range rangeObj = new Range(str);
        return rangeObj;
    }
    public boolean contains(int n){
        if (min <= n && n <= max){
            return true;
        }
        return false;
    }
    public int getMin(){
        return min;
    }
    public int getMax(){
        return max;
    }
}

import java.util.StringTokenizer；
公共类范围{
公共静态int-min；
公共静态int max；
公共静态字符串str；
公共范围（字符串s）{
str=s；
}
公共静态范围解析（字符串s）{
//射程
如果（s）包含（“-”）{
StringTokenizer parse=新的StringTokenizer，“-”；
字符串strMin=parse.nextToken（）；
min=整数.parseInt（strMin）；
字符串strMax=parse.nextToken（）；
max=整数.parseInt（strMax）；
}否则{
最小值=整数.parseInt（s）；
最大值=最小值；
}
量程OBJ=新量程（str）；
返回范围OBJ；
}
公共布尔包含（int n）{
如果（min我认为排序方法应该是这样的（只是sortYear（）的一个例子），那么其他方法应该遵循相同的模式。但是，我想对于不同的排序标准重用排序算法是有意义的

public void sortYear(Song[] song){
        int in, out;

        for (out = 1; out < song.length; out++) {
            Song temp = song[out];
            in = out;

            while (in > 0 && song[in - 1].getYear() > temp.getYear() ) {
                song[in] = song[in - 1];
                --in;
            }
            song[in] = temp;
        }
    }

publicsvoidsortyear（歌曲[]歌曲）{
int-in，out；
for（out=1；out0&&song[in-1].getYear（）>temp.getYear（）中）{
宋[in]=宋[in-1]；
--在；
}
宋[英]=临时工；
}
}
根据我的意见，您不应该对集合进行变异。它应该包含所有元素。但您应该能够根据需要对其进行筛选或排序。
我建议使用google collections guava库

你的班级歌曲可以更多

public final class Song {
  public final String title;
  public final String artist;
  public final int year;
  public final int rank;

  public Song(final String title, final String artist, final int year, final int rank) {
    this.year = year;
    this.rank = rank;
    this.artist = artist;
    this.title = title;
  }

  // With Integer you have the function CompareTo so, you can use Integer instead of int
  public final Integer getYear() {
    return year;
  }

  public final Integer getRank() {
    return rank;
  }

  public final String getArtist() {
    return artist;
  }

  public final String getTitle() {
    return title;
  }

  public final String toString() {
    return String.format(year + " " + rank + " " + artist + " - " + title + "\n");
  }
}

您的排序函数可以如下所示：解析可以移动到dedecated类以分离关注点

public List<Song> sortByYear() {
    Collections.sort(songs, new Comparator<Song>() {
        public int compare(final Song first, final Song second) {
            return first.getYear().compareTo(second.getYear());
        }
    });
    return songs;
}

public List sortByYear（）{
Collections.sort（歌曲、新比较器（）{
公共整数比较（第一首最终歌曲，第二首最终歌曲）{
复述
public List<Song> sortByYear() {
    Collections.sort(songs, new Comparator<Song>() {
        public int compare(final Song first, final Song second) {
            return first.getYear().compareTo(second.getYear());
        }
    });
    return songs;
}

public Collection<Song> filterYear(final Range range) {
    return Collections2.filter(songs, new Predicate<Song>() {
        public boolean apply(final Song song) {
            return range.contains(song.getYear());
        }
    });
}

import com.google.common.base.Predicate;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;

import static com.google.common.collect.Collections2.filter;
import static com.google.common.collect.Lists.newArrayList;
import static java.util.Collections.sort;
import static java.util.Collections.unmodifiableCollection;

public class SongCollection {
  public final ArrayList<Song> songs;

  public SongCollection(final ArrayList<Song> songs) {
      this.songs = newArrayList(songs);
  }

  public Collection<Song> filterYear(final Range range) {
      return unmodifiableCollection(filter(songs, new Predicate<Song>() {
        public boolean apply(final Song song) {
            return range.contains(song.getYear());
        }
      }));
  }

  public Collection<Song> filterRank(final Range range) {
    return unmodifiableCollection(filter(songs, new Predicate<Song>() {
        public boolean apply(final Song song) {
            return range.contains(song.getRank());
        }
    }));
  }

  public Collection<Song> filterArtist(final String value) {
    return unmodifiableCollection(filter(songs, new Predicate<Song>() {
        @Override
        public boolean apply(Song song) {
            return song.getArtist().contains(value);
        }
    }));
   }

   public Collection<Song> filterTitle(final String title) {
    return unmodifiableCollection(filter(songs, new Predicate<Song>() {
        public boolean apply(Song song) {
            return song.getTitle().equals(title);
        }
    }));
  }

  public Collection<Song> sortByYear() {
    sort(songs, new Comparator<Song>() {
        public int compare(final Song first, final Song second) {
            return first.getYear().compareTo(second.getYear());
        }
    });
    return unmodifiableCollection(songs);
  }

  public void sortByRank() {
   ...
  }

  public void sortArtist() {
   ...
  }

  public void sortByTitle() {
    ...
  }

  // prints the songs
  public void print() {
    for (final Song song : songs) {
        System.out.print(song.toString());
    }
  }
}