How can I sort a Ranking list using a specific column from a file and print the whole file sorted?Java

Question

Already done this but can't make it work.

Also tried to create another while ((line = br.readLine()) != null) {}, and placed the sort before it, but it won't read this while so it wouldnt print anithing.

The file looks like this:

    1-Fred-18-5-0

    2-luis-12-33-0

    3-Helder-23-10-0

And wanted it to print like this:

    2-luis-12-33-0

    3-Helder-23-10-0

    1-Fred-18-5-0

---

public static void lerRanking() throws IOException {
        File ficheiro = new File("jogadores.txt");

        BufferedReader br = new BufferedReader(new FileReader(ficheiro));
        List<Integer> jGanhos = new ArrayList<Integer>();
        int i = 0;
        String line;
        String texto = "";

        while ((line = br.readLine()) != null) {

            String[] col = line.split("-");
            int colunas = Integer.parseInt(col[3]);
            jGanhos.add(colunas);

            i++;
            if(i>=jGanhos.size()){
                Collections.sort(jGanhos);
                Collections.reverse(jGanhos);
                for (int j = 0; j < jGanhos.size(); j++) {
                    if(colunas == jGanhos.get(i)){
                        texto = texto + line + "\n";    
                    }
                }
            }
        }    
        PL(texto);
}

Answer 1

Make it step by step:

public static void lerRanking() throws IOException {
    File ficheiro = new File("jodagores.txt");

    // read file
    BufferedReader br = new BufferedReader(new FileReader(ficheiro));
    List<String> lines = new ArrayList<>();
    String line;
    while ((line = br.readLine()) != null) {
        lines.add(line);
    }

    // sort lines
    lines.sort(new Comparator<String>() {
        @Override
        public int compare(String s1, String s2) {
            // sort by 3rd column descending
            return Integer.parseInt(s2.split("-")[3]) - Integer.parseInt(s1.split("-")[3]);
        }
    });

    // concat lines
    String texto = "";
    for (String l : lines) {
        texto += l + "\n";
    }

    System.out.println(texto);

    // PL(texto);

}

Answer 2

The easiest way is to first create a class that will hold the data from your file provided your lines keep the same format

public class MyClass {

  private Integer column1;
  private String column2;
  private Integer column3;
  private Integer column4;
  private Integer column5;

  public MyClass(String data) {
    String[] cols = data.split("-");
    if (cols.length != 5) return;

    column1 = Integer.parseInt(cols[0]);
    column2 = cols[1];
    column3 = Integer.parseInt(cols[2]);
    column4 = Integer.parseInt(cols[3]);
    column5 = Integer.parseInt(cols[4]);
  }

  public synchronized final Integer getColumn1() {
    return column1;
  }

  public synchronized final String getColumn2() {
    return column2;
  }

  public synchronized final Integer getColumn3() {
    return column3;
  }

  public synchronized final Integer getColumn4() {
    return column4;
  }

  public synchronized final Integer getColumn5() {
    return column5;
  }

  @Override
  public String toString() {
    return String.format("%d-%s-%d-%d-%d", column1, column2, column3, column4, column5);
  }
}

Next you can get a list of your items like this:

public static List<MyClass> getLerRanking() throws IOException {
  List<MyClass> items = Files.readAllLines(Paths.get("jogadores.txt"))
    .stream()
    .filter(line -> !line.trim().isEmpty())
    .map(data -> new MyClass(data.trim()))
    .filter(data -> data.getColumn4() != null)
    .sorted((o1, o2) -> o2.getColumn4().compareTo(o1.getColumn4()))
    .collect(Collectors.toList());

  return items;
}

This will read your whole file, filter out any blank lines, then parse the data and convert it to MyClass .

It will then make sure that column4 isn't null in the converted objects.

Finally it will reverse sort the objects based off from the value in column 4 and create a list of those items.

To print the results you can do something like this

public static void main(String[] args) {
   List<MyClass> rankingList = getLerRanking();
   rankingList.forEach(item -> System.out.println(item));
}

Since we overrode the toString() method, it will print it out the object as it is displayed in the file.

Hope this helps.

Answer 3

Okay so first of all I thounk you should introduce a Java class (in my code this is ParsedObject ) to manage your objects.

Second it should implement the Comparable<ParsedObject> interface, so you can easily sort it from anywhere in the code (without passing a custom comparator each time).

Here is the full code:

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {
        lerRanking();
    }

    public static void lerRanking() throws IOException {
        File ficheiro = new File("jodagores.txt");
        // read lines to a list
        List<String> lines = readLines(ficheiro);
        // parse them to a list of objects
        List<ParsedObject> objects = ParsedObject.from(lines);
        // sort
        Collections.sort(objects);
        // print the output
        writeLines(objects);
    }

    public static List<String> readLines(File ficheiro) throws IOException {
        // read file line by line
        BufferedReader br = new BufferedReader(new FileReader(ficheiro));
        List<String> lines = new ArrayList<>();
        String line;
        while((line = br.readLine()) != null) {
            lines.add(line);
        }
        br.close(); // THIS IS IMPORTANT never forget to close a Reader :)
        return lines;
    }

    private static void writeLines(List<ParsedObject> objects) throws IOException {
        File file = new File("output.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(file));
        for(ParsedObject object : objects) {
            // print the output line by line
            bw.write(object.originalLine);
        }
        bw.flush();
        bw.close();  // THIS IS IMPORTANT never forget to close a Writer :)
    }


    // our object that holds the information
    static class ParsedObject implements Comparable<ParsedObject> {

        // the original line, if needed
        public String originalLine;
        // the columns
        public Integer firstNumber;
        public String firstString;
        public Integer secondNumber;
        public Integer thirdNumber;
        public Integer fourthNumber;

        // parse line by line
        public static List<ParsedObject> from(List<String> lines) {
            List<ParsedObject> objects = new ArrayList<>();
            for(String line : lines) {
                objects.add(ParsedObject.from(line));
            }
            return objects;
        }

        // parse one line
        public static ParsedObject from(String line) {
            String[] splitLine = line.split("-");
            ParsedObject parsedObject = new ParsedObject();
            parsedObject.originalLine = line + "\n";
            parsedObject.firstNumber = Integer.valueOf(splitLine[0]);
            parsedObject.firstString = splitLine[1];
            parsedObject.secondNumber = Integer.valueOf(splitLine[2]);
            parsedObject.thirdNumber = Integer.valueOf(splitLine[3]);
            parsedObject.fourthNumber = Integer.valueOf(splitLine[4]);
            return parsedObject;
        }

        @Override
        public int compareTo(ParsedObject other) {
            return other.thirdNumber.compareTo(this.thirdNumber);
        }
    }
}

If you have any more question feel free to ask :) An here is an the example objects list after parsing and sorting.