如何对文本文件进行排序并使用Java保存？

Question

I have been asked to make a quiz and in the end of the quiz, what I want to keep are in two separate arrays names[] and scores[]. I have been asked to save the scores in a file using input and output. I have managed to do everything and successfully output the results and save it into the files (eg highscores.txt)

the results are saved like this:

4
name10
name5
name4
name2

the first line indicates how many scores there are in the file as every person who plays the quiz has their score saved. What I am struggling to do is sort the scores to be placed in order of highest to lowest.

I have tried sorting the scores before they are saved in the file but the older scores in the file will not be sorted anymore. Example:

8 
newname10
newname9 
newname8
newname7
name10
name5
name4
name2

im only a beginner so go easy...

Answer 1

What you should do is to create class Person which implements Comparable<Person> and if you are little bit lazy and the amount of data is not large Serializable too.

Then put everything inside TreeSet<Person> and write methods which serialize the TreeSet and deserialize it too.

Like this:

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.TreeSet;

public class Person implements Comparable<Person>, Serializable {
    private String name;
    private int score;

    public Person(String name, int score) {
        this.name = name;
        this.score = score;
        addPerson(this);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public int compareTo(Person o) {
        return score - o.score;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", score=" + score + "]";
    }

    private static TreeSet<Person> classExtension = new TreeSet<Person>();

    private static void addPerson(Person person) {
        classExtension.add(person);
    }

    private static void removePerson(Person person) {
        classExtension.remove(person);
    }

    private static void showExtension() {
        for (Person person : classExtension)
            System.out.println(person);
    }

    public static void serialize() {

        FileOutputStream fos = null;
        ObjectOutputStream oos = null;

        try {
            fos = new FileOutputStream("Person.ser");
            oos = new ObjectOutputStream(fos);

            oos.writeObject(classExtension);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            try {
                if (oos != null)
                    oos.close();
            } catch (IOException e) {
            }
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
            }
        }
    }

    public static void deserialize(){

         FileInputStream fis = null;
         ObjectInputStream ois = null;
         try {
           fis = new FileInputStream("Person.ser"); 
           ois = new ObjectInputStream(fis); 

         classExtension =  (TreeSet<Person>) ois.readObject(); 

         } catch (FileNotFoundException e) {
           e.printStackTrace();
         } catch (IOException e) {
           e.printStackTrace();
         } catch (ClassNotFoundException e) {
           e.printStackTrace();
         } finally {
           // zasoby zwalniamy w finally
           try {
             if (ois != null) ois.close();
           } catch (IOException e) {}
           try {
             if (fis != null) fis.close();
           } catch (IOException e) {}
         }
    }

}

Answer 2

Well, because you don't use any kind of formatting to easily distinguish between username and score (eg: [username]:[score]) you've the problem to separate these two information from each other afterwards.

Anyhow - you need to load the data and reorder them trying to separate the username from the score. Read the file line my line and split the name from the score using regexp (in hope that the user name contains only letters): Pattern.compile("(\\w+)(\\d+)") . You can then use Matcher to get group 1 (the Name) and group 2 (the score). Then you can compare the score and reorder the List

Answer 3

This little program should do the Job.

Bear in mind that this really just sorts a text-file. If you need further processing according to your problem, modify it.

public class LineReader {
    public static void main(String[] args) {
        String file = args[0];
        List<String> _list = new ArrayList<String>();
        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
            for (String line; (line = br.readLine()) != null;) {
                _list.add(line);
            }
        } catch (Exception ex) {
        }
        java.util.Collections.sort(_list, String.CASE_INSENSITIVE_ORDER);
        try(FileWriter writer = new FileWriter(file)) {
            for (String str : _list) {
                writer.write(str + "\n");
            }
            writer.close();
        } catch (IOException ex) {
        }
    }
}

Answer 4

If you're already able to sort the results before writing them to the file, why don't you read all the file before updating It? Then you can put the old data stored in your data structure with the new data,and sort them alla together. Then you should overwrite the old file with the data you already have.

This way could be expensive if your file has a lot of record.

The best way could be to use a collection that keep items in order. Take a look to PriorityQueue class. Then just store it into the file,and load It before adding new elements. You can write the PriorityQueue to a file using an ObjectOutputStream and read it back with an ObjectInputStream.