用JAVA對2個字段的文件中的行進行排序

Question

我在一家有許多COBOL程序的印刷公司工作，並且我的任務是將COBOL程序轉換爲JAVA程序。我在一次轉換中遇到了麻煩。我需要一個文件，每行是一條記錄，並在每一行數據被阻止。一行的

實施例是

60000003448595072410013 FFFFFFFFFFV 80  0001438001000014530020120808060134 

我需要由5位數字數據在19-23個字符通過在一行中第一個字符進行排序，然後。

BufferedReader input; 
BufferedWriter output; 

String[] sort, sorted, style, accountNumber, customerNumber; 
String holder; 

int lineCount; 

int lineCounter() { 

    int result = 0; 
    boolean eof = false; 

    try { 
     FileReader inputFile = new FileReader("C:\\Users\\cbook\\Desktop\\Chemical\\" 
      + "LB26529.fil"); 
     input = new BufferedReader(inputFile); 

     while (!eof) { 

      holder = input.readLine(); 
      if (holder == null) { 
       eof = true; 
      } else { 
       result++; 
      } 
     } 

    } catch (IOException e) { 
     System.out.println("Error - " + e.toString()); 
    } 

    return result; 
} 

chemSort(){ 
    lineCount = this.lineCounter(); 
    sort = new String[lineCount]; 
    sorted = new String[lineCount]; 
    style = new String[lineCount]; 
    accountNumber = new String[lineCount]; 
    customerNumber = new String[lineCount]; 

    try { 
     FileReader inputFile = new FileReader("C:\\Users\\cbook\\Desktop\\Chemical\\" 
      + "LB26529.fil"); 
     input = new BufferedReader(inputFile); 

     for (int i = 0; i < (lineCount + 1); i++) { 
      holder = input.readLine(); 
      if (holder != null) { 
      sort[i] = holder; 
      style[i] = sort[i].substring(0, 1); 
      customerNumber[i] = sort[i].substring(252, 257); 
      } 
     } 
     } catch (IOException e) { 
      System.out.println("Error - " + e.toString()); 
    } 
} 

這是我有這麼遠，我真的不知道從這裏到甚至去，如果這是正確的方式 着手對文件進行排序。文件排序後，它將被存儲到另一個文件中，並用另一個程序再次處理 以準備打印。

Answer 1

List<String> linesAsList = new ArrayList<String>(); 
String line=null; 
while(null!=(line=reader.readLine())) linesAsList.add(line); 

Collections.sort(linesAsList, new Comparator<String>() { 
    public int compare(String o1,String o2){ 
    return (o1.substring(18,23)+o1.substring(0,1)).compareTo(o2.substring(18,23)+o2.substring(0,1)); 
    }}); 

for (String line:linesAsList) System.out.println(line); // or whatever output stream you want 

這款手機的自動更正是搞亂我的回答

Answer 2

文件讀入到一個ArrayList（而不是數組）。使用以下方法：

// to declare the arraylist 
ArrayList<String> lines = new ArrayList<String>(); 

// to add a new line to it (within your reading-lines loop) 
lines.add(input.readLine()); 

然後，排序使用自定義的比較吧：你想要什麼5個位數或兩位數什麼比較

Collections.sort(lines, new Comparator<String>() { 
    public int compare(String a, String b) { 
     String a5 = theFiveNumbersOf(a); 
     String b5 = theFiveNumbersOf(b); 
     int firstComparison = a5.compareTo(b5); 
     if (firstComparison != 0) { return firstComparison; } 
     String a1 = theDigitOf(a); 
     String b1 = theDigitOf(b); 
     return a1.compareTo(b1); 
    } 
}); 

（目前還不清楚，我已經把它們作爲功能爲你填寫）。 最後，寫入到輸出文件：

BufferedWriter ow = new BufferedWriter(new FileOutputStream("filename.extension")); 
for (String line : lines) { 
    ow.println(line); 
} 
ow.close(); 

（增加進口和try/catch根據需要）

Answer 3

此代碼將排序基於主機的排序參數文件。

將3個參數傳遞給類的Sort類。

1. 輸入文件路徑。
2. 輸出文件路徑。
3. 大型機排序格式中的排序參數。在你的情況，該字符串將19,5,CH,A,1,1,CH,A

這一流的SortParameter類，持有的排序參數的實例。在排序參數字符串中，每個4個參數組都有一個實例。除了getDifference方法之外，這個類是一個基本的getter/setter類。 getDifference方法將一些排序比較代碼帶入SortParameter類，以簡化Sort類中的比較代碼。

public class SortParameter { 

    protected int fieldStartByte; 
    protected int fieldLength; 
    protected String fieldType; 
    protected String sortDirection; 

    public SortParameter(int fieldStartByte, int fieldLength, String fieldType, 
      String sortDirection) { 
     this.fieldStartByte = fieldStartByte; 
     this.fieldLength = fieldLength; 
     this.fieldType = fieldType; 
     this.sortDirection = sortDirection; 
    } 

    public int getFieldStartPosition() { 
     return fieldStartByte - 1; 
    } 

    public int getFieldEndPosition() { 
     return getFieldStartPosition() + fieldLength; 
    } 

    public String getFieldType() { 
     return fieldType; 
    } 

    public String getSortDirection() { 
     return sortDirection; 
    } 

    public int getDifference(String a, String b) { 
     int difference = 0; 

     if (getFieldType().equals("CH")) { 
      String as = a.substring(getFieldStartPosition(), 
        getFieldEndPosition()); 
      String bs = b.substring(getFieldStartPosition(), 
        getFieldEndPosition()); 
      difference = as.compareTo(bs); 
      if (getSortDirection().equals("D")) { 
       difference = -difference; 
      } 
     } 

     return difference; 
    } 

} 

的Sort類包含的代碼讀取輸入文件，排序的輸入文件，並寫入輸出文件。這個類可能會使用更多的錯誤檢查。

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
import java.util.List; 

public class Sort implements Runnable { 

    protected List<String> lines; 

    protected String inputFilePath; 
    protected String outputFilePath; 
    protected String sortParameters; 

    public Sort(String inputFilePath, String outputFilePath, 
      String sortParameters) { 
     this.inputFilePath = inputFilePath; 
     this.outputFilePath = outputFilePath; 
     this.sortParameters = sortParameters; 
    } 

    @Override 
    public void run() { 
     List<SortParameter> parameters = parseParameters(sortParameters); 
     lines = read(inputFilePath); 
     lines = sort(lines, parameters); 
     write(outputFilePath, lines); 
    } 

    protected List<SortParameter> parseParameters(String sortParameters) { 
     List<SortParameter> parameters = new ArrayList<SortParameter>(); 
     String[] field = sortParameters.split(","); 
     for (int i = 0; i < field.length; i += 4) { 
      SortParameter parameter = new SortParameter(
        Integer.parseInt(field[i]), Integer.parseInt(field[i + 1]), 
        field[i + 2], field[i + 3]); 
      parameters.add(parameter); 
     } 
     return parameters; 
    } 

    protected List<String> sort(List<String> lines, 
      final List<SortParameter> parameters) { 

     Collections.sort(lines, new Comparator<String>() { 
      @Override 
      public int compare(String a, String b) { 
       for (SortParameter parameter : parameters) { 
        int difference = parameter.getDifference(a, b); 
        if (difference != 0) { 
         return difference; 
        } 
       } 
       return 0; 
      } 
     }); 

     return lines; 
    } 

    protected List<String> read(String filePath) { 
     List<String> lines = new ArrayList<String>(); 
     BufferedReader reader = null; 
     try { 
      String line; 
      reader = new BufferedReader(new FileReader(filePath)); 
      while ((line = reader.readLine()) != null) { 
       lines.add(line); 
      } 
     } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } finally { 
      try { 
       if (reader != null) { 
        reader.close(); 
       } 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
     return lines; 
    } 

    protected void write(String filePath, List<String> lines) { 
     BufferedWriter writer = null; 
     try { 
      writer = new BufferedWriter(new FileWriter(filePath)); 
      for (String line : lines) { 
       writer.write(line); 
       writer.newLine(); 
      } 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } finally { 
      try { 
       if (writer != null) { 
        writer.flush(); 
        writer.close(); 
       } 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } 
     } 
    } 

    public static void main(String[] args) { 
     if (args.length < 3) { 
      System.err.println("The sort process requires 3 parameters."); 
      System.err.println(" 1. The input file path."); 
      System.err.println(" 2. The output file path."); 
      System.err.print (" 3. The sort parameters in mainframe "); 
      System.err.println("sort format. Example: 15,5,CH,A"); 
     } else { 
      new Sort(args[0], args[1], args[2]).run(); 
     } 
    } 

}