对对象的ArrayList进行排序(排序后ArrayList不变)

Question

我刚刚完成了一个项目，在这个项目中，我们必须按不同的排序字段对文件中的对象进行ArrayList排序。一切运行正常，但我遇到了一个bug。当我运行代码时，文件对象将按其原始顺序打印出来，并且不会进行排序。

我非常确定这个bug是因为我在集合类中使用的实例变量在排序完成后没有被更改，但我不知道如何修复这个问题。

下面是我的客户机类：

static int bpCount;
static String gene;
static int year;
static String yearString;
static String definition;
static String definitionString;
static String origin;
static String s;

public static void main(String[] args) throws FileNotFoundException{


    ArrayList<VirusObject> virusList = new ArrayList<VirusObject>();
    VirusCollection viruses = new VirusCollection(virusList);

    String folderName = "virusfiles";
    Scanner in = new Scanner(System.in);

    System.out.println("Hello user, this program you are about to use will sort and filter a large selection of virus files that contain various virus genre");

    System.out.println("Do you want to load a directory or file?");

    String userInput = in.nextLine();

    if(userInput.equals("file")){

        openViruses(virusList, folderName);

    }

    Scanner userIn = new Scanner(System.in);

    System.out.println("The current commands are sort, filter, and quit. Choose your commmand: ");

    String input = userIn.nextLine();

    if(input.equals("sort")){
        Scanner userInput3 = new Scanner(System.in);
        System.out.println("The current sorting methods are definition, reference, origin, year, and gene. Choose your sort: ");
        String sort = userInput3.nextLine();

        if(sort.equals("definition")){ //runs sort on temporary array, then runs print method

            viruses.sortDef();
            viruses.printViruses();

        }
        if(sort.equals("reference")){

            viruses.sortRef();
            viruses.printViruses();

        }
        if(sort.equals("origin")){

            viruses.sortOrg();
            viruses.printViruses();

        }
        if(sort.equals("year")){

            viruses.sortYr();
            viruses.printViruses();

        }
        if(sort.equals("gene")){

            viruses.sortGn();
            viruses.printViruses();

        }

        if(sort.equals("quit")){
            System.out.println("Have a good day buddy");
            return;

        }
    }

    if(input.equals("filter")){
        Scanner userInput2 = new Scanner(System.in);
        System.out.println("The current filters are definition, reference, origin, year, and gene. Choose your filter: ");
        String filter = userInput2.nextLine();

        if(filter.equals("definition")){

            System.out.println("What definition do you want to filter out?");
            String defFilter = userInput2.nextLine();
            viruses.printViruses();

        }
        if(filter.equals("reference")){

            System.out.println("Enter a reference or range: ");
            String refRange = userInput2.nextLine();
            viruses.filterYear(Range.parse(refRange));
            viruses.printViruses();

        }
        if(filter.equals("origin")){    

            System.out.println("What origin do you want to filter out?");
            String originFilter = userInput2.nextLine();
            viruses.filterDefinition(originFilter);
            viruses.printViruses();

        }
        if(filter.equals("year")){

            System.out.println("Enter a year or range: ");
            String yearRange = userInput2.nextLine();
            viruses.filterYear(Range.parse(yearRange));
            viruses.printViruses();

        }
        if(filter.equals("gene")){

            System.out.println("What gene do you want to filter out?");
            String geneFilter = userInput2.nextLine();
            viruses.filterDefinition(geneFilter);
            viruses
            .printViruses();

        }

        if(filter.equals("quit")){
            System.out.println("Have a good day buddy");
            return;

        }
    }
}

public static int openViruses(ArrayList<VirusObject> virusList, String folderName) throws FileNotFoundException {
    File folder = new File(folderName);
    File[] listOfFiles = folder.listFiles();
    int countOfFiles = 0;

    for (int i = 0; i < listOfFiles.length; i++) {
        if (listOfFiles[i].isFile()) {
            System.out.println("File " + listOfFiles[i].getName());
            parseFile(virusList, listOfFiles[i]);//parseFile provided by student!
            countOfFiles++;

        } else if (listOfFiles[i].isDirectory()) {
            System.out.println("Directory ignored: " + listOfFiles[i].getName());
        }
    }

    return countOfFiles;
}

public static void parseFile(ArrayList<VirusObject> virusList, File File1) throws FileNotFoundException{

    Scanner readFile = new Scanner(File1);

    while(readFile.hasNextLine()){

        String virusString = readFile.nextLine(); 
        Scanner in = new Scanner(virusString);

        if(virusString.contains("LOCUS")){

            in.next();
            in.next();
            bpCount = in.nextInt();
            in.next();

            gene = in.next();
            in.next();
            in.next();
            yearString = in.next();
            Scanner in2 = new Scanner(yearString);
            in2.useDelimiter("-");
            in2.next();
            in2.next();
            year = in2.nextInt();

        }

        if(virusString.contains("DEFINITION")){

            definitionString = in.nextLine();
            definition = definitionString.split("\\.")[0];


        }

        if(virusString.contains("ORIGIN")){
            if(virusString.contains("1"));
                origin = in.nextLine();

            }       
        }


    VirusObject Virus = new VirusObject(bpCount, gene, year, definition, origin);
    virusList.add(Virus);

    }
}

这就是这个类，所有的东西都是在这里排序的。

public ArrayList<VirusObject> virusList;

public VirusCollection(ArrayList<VirusObject> viruses){

    virusList = viruses; // placeholder to reach filters and sorts (temporary array)

}

public void sortDefinition(VirusObject[] viruses){

    int i;
    int j;

    for (j = 1; j < viruses.length; j++){
        VirusObject temp = viruses[j];
        i = j;

        while ( i> 0 && viruses[i - 1].getDefinition().compareTo(temp.getDefinition()) > 0){ // compareTo method used to compare string to 0
            viruses[i] = viruses[i - 1];
            --i;
        }

        viruses[i] = temp;
    }


}

public void sortReference(VirusObject[] viruses){

    int i;
    int j;

    for (j = 1; j < viruses.length; j++){
        VirusObject temp = viruses[j];
        i=j;


        while ( i > 0 && viruses[i - 1].getReference() > 0){
            viruses[i] = viruses[i - 1];
            --i;
        }

        viruses[i] = temp;
    }


}

public void sortYear(VirusObject[] viruses){

    int i;
    int j;

    for (j = 1; j < viruses.length; j++){
        VirusObject temp = viruses[j];
        i = j;

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

        viruses[i] = temp;
    }


}

public void sortOrigin(VirusObject[] viruses){

    int i;
    int j;

    for (j = 1; j < viruses.length; j++){
        VirusObject temp = viruses[j];
        i = j;

        while ( i > 0 && viruses[i - 1].getOrigin().compareTo(temp.getOrigin()) > 0){
            viruses[i] = viruses[i - 1];
            --i;
        }

        viruses[i] = temp;
    }


}

public void sortGene(VirusObject[] viruses){

    int i;
    int j;

    for (j = 1; j < viruses.length; j++){
        VirusObject temp = viruses[j];
        i = j;

        while ( i > 0 && viruses[i - 1].getGene().compareTo(temp.getDefinition()) > 0){
            viruses[i] = viruses[i - 1];
            --i;
        }

        viruses[i] = temp;
    }
}

public void printViruses(){

    for (final VirusObject Virus : virusList){
        System.out.println(Virus.toString());
    }
}

public void sortDef(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]); // runs the sorting methods on a temporary array, makes it available to client as method
    sortDefinition(array);

}

public void sortRef(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]);
    sortReference(array);

}

public void sortYr(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]);
    sortYear(array);


}

public void sortOrg(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]);
    sortOrigin(array);

}

public void sortGn(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]);
    sortGene(array);

    }
}

任何帮助都将不胜感激。谢谢

Answer 1

我认为问题在于调用virusList.toArray(...)，它会创建一个与列表具有相同值的新数组，然后对该数组进行排序。现在您有了一个排序数组，但是原始列表(virusList)并没有改变！您需要将排序后的结果用于更新virusList (将其转换为ArrayList或其他格式)。

Answer 2

这就是你的错误！

当您根据用户输入调用排序函数时，例如：

viruses.sortDef();

您正在将集合中的所有元素转移到一个ArrayList中，然后对该ArrayList进行排序。

这实现了对您在此处创建的临时ArrayList实例的排序：

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]); // runs the sorting methods on a temporary array, makes it available to client as method

并且您的实际集合实例仍未排序，因为您没有对其执行任何操作！

Answer 3

在执行排序的每个方法中，将引用从列表复制到数组，然后对数组进行排序。然后打印使用virusList进行打印。排序后的引用永远不会重新设置到virusList中。有许多不同的方法可以解决这个问题，包括对底层列表进行排序，但对代码的最小更改可能是：

public void sortDef(){

    VirusObject[] array = virusList.toArray(new VirusObject[virusList.size()]); // runs the sorting methods on a temporary   array, makes it available to client as method
    sortDefinition(array);
    virusList = new ArrayList<VirusObject>(Arrays.asList(array));
}

并对您的所有排序方法进行类似的更改。