Question

基本上，我有一个名为highscore.txt的文件，其中包含以下内容：

24 01詹姆斯7 24 01詹姆斯11
24 01詹姆斯1234
24 01詹姆斯3
24 01詹姆斯3
24 01詹姆斯41
24 01詹姆斯431
24 01詹姆斯3
24 01詹姆斯2
24 01詹姆斯444
24 01詹姆斯44
24 01詹姆斯876
24 01詹姆斯865
24 01詹姆斯1

[我想做的是创建一个包含十个'空格'（0-9）的数组。十个是这里的行，最后的数字最小。]

换句话说：数组[0]为“24 01 James 1”，数组[9]为24 01 James 444

我尝试了什么：

FileInputStream fstream = null;
try {
fstream = new FileInputStream("highscore.txt");
} catch (FileNotFoundException ex) {}
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String strLine;

List<String> list = new ArrayList<String>();

try {
while ((strLine = br.readLine()) != null)   {    
list.add(strLine);} } 
catch (IOException ex) {}

String[] stringArr = list.toArray(new String[0]);

现在，我不完全确定该怎么做：

我在想，也许：

 for(int i = 0; i < stringArr.length; i++){
 String words[] = stringArr[i].split(" "); }

然后，我可以使用单词[3]来检查最后的数字吗？

无论如何，我非常感谢任何帮助，我不太清楚如何处理这个问题，我刚刚开始使用Java。

谢谢！

Answer 1

我想这是一个游戏，所以你可以在构造函数中创建一个包含名称和分数的类HighscorePlayer。然后，您可以直接从words[]向其提供信息，并将其存储在与stringArr[]相同大小的数组中。您可能需要使用Integer.parseInt(string)将字符串转换为int。这将为您提供一系列HighscorePlayer个，每个都包含一个名称和分数。

现在你需要能够按照得分值对球员进行排序。为此，HighscorePlayer需要实施Comparable

class HighscorePlayer implements Comparable<HighscorePlayer>{
    public int score;
    public String name;

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

    @Override
    public int compareTo(HighscorePlayer player) {
        return Integer.compare(score, player.score);
    }
}

然后你可以运行Arrays.sort(players)并遍历该数组。这样您就可以保留与分数相关联的名称，并允许您在需要时添加更多相关信息。

Answer 2

如果你真的只需要得分，这就是我的建议：

...
catch(IOException ex){}
String[] stringArr = new String[list.size()];
stringArr = list.toArray(stringArr);
int score[] = new int[stringArr.length];

for(int i = 0; i < score.length; i++){
    for (String strScore : stringArr[i].split("24 01 James "))
    {
       score[i] = Integer.parseInt(strScore);
    }
 }

现在，您将所有分数存储在整数数组中。只需按升序排序并采用前10个元素：）

以下是我用来回答你问题的一些消息来源：

http://www.tutorialspoint.com/java/number_parseint.htm

http://www.tutorialspoint.com/java/java_string_length.htm

Convert ArrayList<String> to String[] array （最重要的一个）

Answer 3

我认为使用Object是唯一的方法，因为它允许在其中存储不同的类型。这对于对象数组的排序是理想的，因为排序int不会出错。

public class JavaApplication9 {

    static private ReadFile readFile;

    public static void main(String[] args) {
        readFile = new ReadFile();
        readFile.readnewFile();
        readFile.wordRead();
        readFile.convertToObject();
        readFile.sortIng();
        readFile.display();
    }
}

第二档：

public class WordsClass {

    final public Object[][] finalTest;
    private int nElems;

    public WordsClass(String theDay, String theMonth, String theName, String theScore) {
        finalTest = new Object[14][4];
        nElems = 0;
    }

    public Object myObject(String a, String b, String c, String d) {
        finalTest[nElems][0] = Integer.parseInt(a);
        finalTest[nElems][1] = Integer.parseInt(b);
        finalTest[nElems][2] = c;
        finalTest[nElems][3] = Integer.parseInt(d);
        nElems++;
        return finalTest;
    }
}

和第三个文件：

public class ReadFile {

    static private FileInputStream fstream;
    static private DataInputStream in;
    static private BufferedReader br;
    static private String strLine;
    static private Object[][] words;
    static private int nElems;

    WordsClass wordsClass = new WordsClass(null, null, null, null);

    public ReadFile() {
        words = new Object[14][4];
        nElems = 0;
    }

    public void readnewFile() throws FileNotFoundException {
        fstream = new FileInputStream("highscore.txt");
        in = new DataInputStream(fstream);
        br = new BufferedReader(new InputStreamReader(in));
        // wordRead(); 
    }

    public Object wordRead() throws IOException {
        try {
            while ((strLine = br.readLine()) != null) {
                words[nElems] = strLine.split(" ");
                nElems++;
            }
        } catch (IOException e) {
        }
        br = null;
        in = null;
        fstream = null;
        return words;
    }

    public Object convertToObject() {

        for (Object[] word : words) {
            wordsClass.myObject(word[0].toString(), word[1].toString(), 
                   word[2].toString(), word[3].toString());
        }
        words = null;
        return wordsClass;
    }

    public boolean sortIng() {
        Arrays.sort(wordsClass.finalTest, new Comparator<Object[]>() {
            @Override
            public int compare(final Object[] w1, final Object[] w2) {
                final Integer a = Integer.parseInt(w1[3].toString());
                final Integer b = Integer.parseInt(w2[3].toString());
                return a.compareTo(b);
            }
        });
        return true;
    }

    public void display() {
        for (Object[] finalTest : wordsClass.finalTest) {
            for (Object finalTest1 : finalTest) {
                System.out.print(finalTest1 + " ");
            }
            System.out.println("");
        }
    }
}

所有这些都给出了输出：

24 1 James 1
24 1 James 2
24 1 James 3
24 1 James 3
24 1 James 3
24 1 James 7
24 1 James 11
24 1 James 41
24 1 James 44
24 1 James 431
24 1 James 444
24 1 James 865
24 1 James 876
24 1 James 1234

由于按String排序并不按预期工作。它排序好，但它给出了错误的结果。它排序为1，所以分别为1,11,1234,2等。

感谢这个CompareTo/Sorting 2D array of Strings AND Integers话题。这帮助我找出Object整理出来。

编辑：我清理了一下。最好保持main尽可能干净，并且仅用于调用其他类中的方法。添加私人和公共参考，并设置一些使用后不再需要的null。所有这些都加快了性能。（很多）。

JAVA按数字顺序对数组进行排序

3 个答案: