Sorting lines in a file by 2 fields with JAVA

Question

I work at a printing company that has many programs in COBOL and I have been tasked to convert the COBOL programs into JAVA programs. I've run into a snag in the one conversion. I need to take a file that each line is a record and on each line the data is blocked.

Example of a line is

60000003448595072410013 FFFFFFFFFFV 80     0001438001000014530020120808060134

I need to sort data by a 5 digit number at the 19-23 characters and then by the very first character on a line.

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

This what I have so far and I'm not really sure where to go from here or even if this is the correct way to go about sorting the file. After the file is sorted it will be stored into another file and processed again with another program for it to be ready for printing.

Answer 1

This code will sort a file based on mainframe sort parameters.

You pass 3 parameters to the main method of the Sort class.

1. The input file path.
2. The output file path.
3. The sort parameters in mainframe sort format. In your case, this string would be 19,5,CH,A,1,1,CH,A

This first class, the SortParameter class, holds instances of the sort parameters. There's one instance for every group of 4 parameters in the sort parameters string. This class is a basic getter / setter class, except for the getDifference method. The getDifference method brings some of the sort comparator code into the SortParameter class to simplify the comparator code in the Sort class.

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

}

The Sort class contains the code to read the input file, sort the input file, and write the output file. This class could probably use some more error checking.

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

}

Answer 2

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

This phone's autocorrect is messing up my answer

Answer 3

Read the file into an ArrayList (instead of an array). Use the following methods:

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

Then, sort it using a custom Comparator:

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

(It is unclear what 5 digits or what digit you want to compare; I've left them as functions for you to fill in). Finally, write it to the output file:

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

(adding imports and try/catch as needed)