無限while循環，以及問題閱讀文件

Question

程序的說明：

我有我的這個計劃，旨在從 閱讀每一個字一個文件（大單），然後檢查詞語已經存在於保存唯一字詞的 字詞數組中。如果不是，則將單詞 添加到數組末尾，並將+1添加到唯一的字詞計數器以及將 添加到位於相同索引處的計數陣列。如果該單詞已位於數組中的某個位置，則應該找到位置 索引號和 計數陣列中的相同索引號將值增加1。當文件包含更多內容時，它應該執行此操作。我也不允許使用HashMaps。

但是，當程序要讀取文件時，我的程序會進入一個無限的while循環，一眨眼之間，特殊字的數量很容易超過100.000，但它最多應該是5000 ...

下面是代碼：

class Oblig3A{ 
    public static void main(String[]args){ 

    OrdAnalyse oa = new OrdAnalyse(); 
    String filArgs=args[0]; 
    oa.analyseMetode(filArgs); 
    } 
} 

class OrdAnalyse{ 
    void analyseMetode(String filArgs){ 

    //Begins with naming all of the needed variables 
    Scanner input, innfil; 
    String[] ord, fortelling; 
    int[] antall; 
    int antUnikeOrd, totalSum; 
    PrintWriter utfil; 

    //Declaring most of them. 
    input=new Scanner(System.in); 
    ord=new String[5000]; 
    antall=new int[5000]; 
    antUnikeOrd=0; 
    totalSum=0; 
    try{ 
     innfil=new Scanner(new File(filArgs)); 



    //The problem is located here somewhere: 
     while(innfil.hasNext()){ 
     fortelling=innfil.nextLine().toLowerCase().split(" "); 

     ord[0]=innfil.next().toLowerCase(); 

      for(int i=0; i<fortelling.length; i++){ 
      for(int j=0; j<5000; j++){ 
      if(fortelling[i].equals(ord[j])){ 
       antall[j]+=1; 
       System.out.print("heo"); 
      }else{ 
       ord[j]=fortelling[i]; 
       antall[j]+=1; 
       antUnikeOrd+=1; 
       } 
      System.out.println(ord.length); 
      System.out.println(antUnikeOrd); 

      } 
     } 
     } 
     innfil.close(); 
    }catch(Exception e){ 
     e.printStackTrace(); 
    } 

    // Here the program will write all the info acquired above into a file called Oppsummering.txt, which it will make. 
    try{ 
     utfil=new PrintWriter(new File("Oppsummering.txt")); 

     for(int i=0; i<antall.length; i++){ 
     totalSum+=antall[i]; 
     } 

     utfil.println("Antall ord lest: " +totalSum+ " og antall unike ord: "+antUnikeOrd); 

     for(int i=0; i<ord.length; i++){ 

     utfil.println(ord[i]+(" ")+antall[i]); 
     } 
     utfil.close(); 
    }catch(Exception e){ 
     e.printStackTrace(); 
    } 
    } 
} 

Answer 1

/The problem is located here somewhere: 
    Scanner keepTrack=infill.next(); 
    while(keepTrack.next().Equals(null)){ 
    fortelling=innfil.nextLine().toLowerCase().split(" "); 

    ord[0]=innfil.next().toLowerCase(); 

     for(int i=0; i<fortelling.length; i++){ 
     for(int j=0; j<5000; j++){ 
     if(fortelling[i].equals(ord[j])){ 
      antall[j]+=1; 
      System.out.print("heo"); 
     }else{ 
      ord[j]=fortelling[i]; 
      antall[j]+=1; 
      antUnikeOrd+=1; 
      } 
     System.out.println(ord.length); 
     System.out.println(antUnikeOrd); 

     } 
    } 
    infill=infill.next(); 
    keepTrack=infill; 
    } 
    innfil.close(); 
} 

試試這個我不知道，如果它的工作或沒有！

我認爲問題在於你只在一個元素上循環而不是全部循環。

祝你好運！

Answer 2

我沒有你的問題的直接答案，但我有工作和更簡單的解決方案給你。 我必須承認，我很懶惰，分析你的代碼對於像我這樣的人來說非常重要：部分原因在於它不是英文的，部分是因爲如果你使用了正確的容器，代碼可能會簡單得多。我已經用較小的文件測試了你的代碼，並且它也永遠循環，所以尺寸無關緊要。

正如我所說，如果使用適當的容器，可以做得更簡單。 所以這裏是我的解決方案：

Map<String, Integer> wordsMap = new HashMap<String, Integer>(); 

    Scanner scanner = new Scanner(new File("C:\\temp\\input.txt")); 
    while(scanner.hasNext()){ 
     String word = scanner.next(); 
     wordsMap.put(word ,wordsMap.containsKey(word) ? wordsMap.get(word) + 1 : 1); 
    } 

    System.out.println("Total number of unique words: "+wordsMap.size()); 
    for(String word : wordsMap.keySet()){ 
     System.out.println("Word \""+word+"\" occurs "+wordsMap.get(word)+" times."); 
    } 

計數邏輯是在while循環。打印出現在for循環中，您可以使用文件更改系統輸出，並且您應該沒有問題

Answer 3

這裏有幾個不同的問題會阻止您的程序按預期工作。首先，您對掃描儀的使用沒有給您可能預期的結果。假設我們有一個非常簡單的輸入文件，內容如下：

apple banana carrot 
alligator baboon crocodile 

首先，掃描儀被放置在文件的開始，像這樣：

|apple banana carrot 
alligator baboon crocodile 

當你調用.nextLine()的掃描儀將其光標移到行尾並返回它傳遞的所有數據。所以fortelling被置1 ["apple", "banana", "carrot"]和掃描儀定位在第二行開始，像這樣：

apple banana carrot 
|alligator baboon crocodile 

所以，當你調用.next()，ord[0]變得設置爲「鱷魚」，光標再次移動。掃描儀不可倒帶，因此如果您使用下一種方法之一讀取了一些數據，則無法使用同一臺掃描儀再次讀取它。

你的第二個問題是你的循環內部的邏輯。 fortelling[i].equals(ord[j])將始終評估爲false，因爲fortelling中的字符串都不是「鱷魚」。因此，以下行始終執行：

ord[j]=fortelling[i]; 
antall[j]+=1; 
antUnikeOrd+=1; 

因爲你的內部循環，這些線路將在該文件的第一行中重複5000次，每一個字。因此，外循環的第一次迭代之後，該變量將是這樣的：

ord : [ "apple", "apple", "apple", "apple", "apple", ... ] 
antall : [ 1, 1, 1, 1, 1, ... ] 
antUnikeOrd : 5000 

第二後，它會：

ord : [ "banana", "banana", "banana", "banana", "banana", ... ] 
antall : [ 2, 2, 2, 2, 2, ... ] 
antUnikeOrd : 10000 

然後：

ord : [ "carrot", "carrot", "carrot", "carrot", "carrot", ... ] 
antall : [ 2, 2, 2, 2, 2, ... ] 
antUnikeOrd : 15000 

這就是爲什麼你計數的獨特單詞增加得如此之快。您爲每個處理的單詞添加5000。即使掃描儀問題不存在，這裏的邏輯也是不正確的。如果一個單詞與現有單詞匹配，則只需執行一次操作，而不是5000次。良好的break聲明可能會解決這個問題。

另外，您正在使用while循環的每次迭代更改ord[0]的值。如果這個數組應該是一個唯一的單詞列表，這不可能是正確的。 ord中的每個項目都應設置一次且僅設置一次。

我並不是說這成爲一個大的代碼審查，但你去了。希望對你有幫助！