2017-03-09 129 views
0

我刚刚完成了一个项目,我们必须通过不同的排序字段对来自文件的对象的ArrayList进行排序。一切运行良好,但我遇到了一个错误。当我运行代码时,文件对象按原始顺序打印出来,并且不进行排序。对对象的ArrayList进行排序(ArrayList在排序后没有被更改)

我很确定这个错误是我在集合类中使用的实例变量在排序完成后没有被更改,但我不知道如何解决这个问题。

这里是我的客户端类:

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

    } 
} 

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

+1

你为什么写自己的排序而不使用内置排序方法? –

+0

从创建[mcve]开始。你提了一大堆没有关系的代码?! – GhostCat

+0

@JimGarrison我们的老师希望我们写我们自己的方法,而不是使用Collections.sort –

回答

1

我认为问题是你打电话virusList.toArray(...),它创建一个新的数组与列表相同的值,然后你排序该数组。您现在有一个排序数组,但原始列表(virusList)尚未更改!你需要把你的排序结果,并用它来更新virusList(将其转换为ArrayList或其他)。

+0

谢谢。你的解释很清楚,很容易理解。 –

0

在执行排序的每个方法中,将列表中的引用复制到数组中,然后对数组进行排序。然后打印使用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)); 
} 

也要为自己的所有排序方法了类似的变化。

+0

这解决了这个问题,谢谢你的帮助。我现在知道了! –

1

这是您的错误!

当你打电话给你的排序功能,根据用户的输入,例如:

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 

而且因为你在它执行任何操作的实际征收情况仍然未分类!

+0

感谢您的帮助!你的解释帮助我了解什么是错的 –