如何使用Java对文本文件中的记录进行排序？

对txt文件中的数据进行了一些修改。 我尝试了建议的代码，但我没有成功地用这种格式在txt文件中再次写入它。我尝试了collection.sort，但它以长行方式写入数据

我的txt文件包含以下数据：

Monday
Jessica  Run      20mins
Alba     Walk     20mins
Amy      Jogging  40mins
Bobby    Run      10mins
Tuesday
Mess     Run      20mins
Alba     Walk     20mins
Christy  Jogging  40mins
Bobby    Run      10mins

如何按升序排序这些数据，并在排序后将其再次存储在txt文件中

Monday
Alba     Walk     20mins
Amy      Jogging  40mins
Bobby    Run      10mins
Jessica  Run      20mins
Tuesday
Alba     Walk     20mins
Bobby    Run      10 mins
Christy  Jogging  40mins
Mess     Run      20mins
Jessica  Run      20mins

---

使用

排序

：

aaron@ares ~$ sort data.txt 
Alba     Walk     20mins
Amy      Jogging  40mins
Bobby    Run      10mins
Jessica  Run      20mins

aaron@ares ~$ sort data.txt > sorted.txt
aaron@ares ~$ cat sorted.txt
Alba     Walk     20mins
Amy      Jogging  40mins
Bobby    Run      10mins
Jessica  Run      20mins

。。。或者使用

python

：

aaron@ares ~$ python -c "import sys; print ''.join(sorted(sys.stdin))" < data.txt > sorted.txt
aaron@ares ~$ cat sorted.txt 
Alba     Walk     20mins
Amy      Jogging  40mins
Bobby    Run      10mins
Jessica  Run      20mins

aaron@ares~$python-c“导入系统；打印“”。加入（已排序（sys.stdin））”sorted.txt
aaron@ares~$cat.txt
阿尔巴步行20分钟
艾米慢跑40分钟
鲍比跑10分钟
杰西卡跑20分钟

有一个包含3个参数的类：名称、操作和长度

打开文件进行阅读，逐字阅读，为每个人创建一个新的类实例，并填充适当的值，然后将该实例插入到某个集合中

通过编写自己的排序方法或（更好的选择）使用Java排序函数之一对集合进行排序

打开另一个文件进行写入，并以相同方式写入已排序的集合

---

如果您无法将上述操作转换为代码，请购买《CoreJava》一书并好好阅读，或者希望这里的人慷慨大方地为您提供完整的代码。：）

如果该文件中没有可怕的数据量，请尝试以下操作：

将其所有内容加载到

String s = <<file contents>>;

String[] strings = s.split(<<here comes lovely regex something like \w+\s\w+\s\w>>);

Arrays.sort(strings);

for (String str : strings) {
  write  str  to your output file;
}

strings=；
String[]strings=s.split（）；
数组。排序（字符串）；
for（字符串str:strings）{
将str写入输出文件；
}

---

但我太累了，无法提出更明智的建议……

我想到了以下几点：

import java.io.*;
import java.util.*;

public class Sort {

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new FileReader("fileToRead"));
        Map<String, String> map=new TreeMap<String, String>();
        String line="";
        while((line=reader.readLine())!=null){
            map.put(getField(line),line);
        }
        reader.close();
        FileWriter writer = new FileWriter("fileToWrite");
        for(String val : map.values()){
            writer.write(val);  
            writer.write('\n');
        }
        writer.close();
    }

    private static String getField(String line) {
        return line.split(" ")[0];//extract value you want to sort on
    }
}

import java.io.*；
导入java.util.*；
公共类排序{
公共静态void main（字符串[]args）引发异常{
BufferedReader reader=新BufferedReader（新文件读取器（“文件读取器”）；
Map Map=newtreemap（）；
字符串行=”；
而（（line=reader.readLine（））！=null）{
map.put（getField（line），line）；
}
reader.close（）；
FileWriter writer=新的FileWriter（“fileToWrite”）；
for（字符串val:map.values（））{
writer.write（val）；
writer.write（'\n'）；
}
writer.close（）；
}
私有静态字符串getField（字符串行）{
返回行。拆分（“”[0]；//提取要排序的值
}
}

这是一种相当懒惰的方法，因为您只对第一个单词进行排序：

    ArrayList<String> rows = new ArrayList<String>();
    BufferedReader reader = new BufferedReader(new FileReader("input.txt"));

    String s;
    while((s = reader.readLine())!=null)
        rows.add(s);

    Collections.sort(rows);

    FileWriter writer = new FileWriter("output.txt");
    for(String cur: rows)
        writer.write(cur+"\n");

    reader.close();
    writer.close();

ArrayList rows=new ArrayList（）；
BufferedReader=新的BufferedReader（新文件读取器（“input.txt”）；
字符串s；
而（（s=reader.readLine（））！=null）
行。添加（s）；
集合。排序（行）；
FileWriter=newfilewriter（“output.txt”）；
用于（字符串当前：行）
writer.write（cur+“\n”）；
reader.close（）；
writer.close（）；

导入java.io.*；
导入java.util.*；
公共类Sort1{
公共静态void main（字符串[]args）引发异常{
BufferedReader reader=新的BufferedReader（新文件读取器（“fileToRead.txt”）；
Map Map=newtreemap（）；
字符串行=”；
而（（line=reader.readLine（））！=null）{
map.put（getField（line），line）；
}
reader.close（）；
BufferedWriter writer=新的BufferedWriter（新的FileWriter（“fileToWrite1.txt”）；
for（字符串val:map.values（））{
writer.write（val）；
writer.newLine（）；
}
writer.close（）；
}
私有静态字符串getField（字符串行）{
返回行。拆分（“”[0]；//提取要排序的值
}
}

打包com.myFiles；
导入java.io.BufferedReader；
导入java.io.FileReader；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.io.PrintWriter；
导入java.util.ArrayList；
导入java.util.Collections；
公共类文件读取器{
公共静态void main（字符串[]args）引发IOException{
BufferedReader reader=null；
PrintWriter outputStream=null；
ArrayList行=新的ArrayList（）；
试一试{
reader=newbufferedreader（newfilereader（“Input.txt”）；
outputStream=新的PrintWriter（新的FileWriter（“Output.txt”）；
字符串文件；
而（（file=reader.readLine（））！=null）{
行。添加（文件）；
}
集合。排序（行）；
String[]strArr=rows.toArray（新字符串[0]）；
用于（字符串cur:strArr）
outputStream.println（cur）；
}最后{
if（读卡器！=null）{
inputStream.close（）；
}
if（outputStream！=null）{
outputStream.close（）；
}
}
}
}

此解决方案使用Java 8流API

考虑到

Files.write

将

Stream

作为第二个参数，因此我们需要通过

map（Function.identity（））

进行类型转换

import java.io.IOException；
导入java.nio.file.*；
导入java.util.function.function；
导入java.util.stream.stream；
带有流的公共类文件端口{
公共静态void main（字符串[]args）引发IOException{
Path initialFile=Path.get（“files/initial.txt”）；
Path sortedFile=Path.get（“files/sorted.txt”）；
Stream sortedLines=Files.lines（initialFile）.sorted（）.map（Function.identity（））；
write（sortedFile，sortedLines:：iterator，StandardOpenOption.CREATE）；
}
}

bah。。。这不在问题中。。。我讨厌人们那样做；它可能无法准确回答问题，但如果您只做了一次性操作，则使用

排序
可以节省编写实用程序的时间。@Sujoy在我发布答案后更改了问题。不支持重复键。这一点很好，但如果我认为这是一个要求，我会以不同的方式编写它
import java.io.*;
import java.util.*;

public class Sort1 {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new FileReader("fileToRead.txt"));
        Map<String, String> map=new TreeMap<String, String>();
        String line="";
        while((line=reader.readLine())!=null){
                map.put(getField(line),line);
        }
        reader.close();
        BufferedWriter writer = new BufferedWriter(new FileWriter("fileToWrite1.txt"));
        for(String val : map.values()){
                writer.write(val);      
                writer.newLine();
        }
        writer.close();
    }

    private static String getField(String line) {
        return line.split(" ")[0];//extract value you want to sort on
    }
}

package com.myFiles;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;

public class FilesReaderWriter {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        PrintWriter outputStream = null;
        ArrayList<String> rows = new ArrayList<String>();

        try {
            reader  = new BufferedReader(new FileReader("Input.txt"));
            outputStream = new PrintWriter(new FileWriter("Output.txt"));

            String file;
            while ((file = reader .readLine()) != null) {
                rows.add(file);
            }
            Collections.sort(rows);
            String[] strArr= rows.toArray(new String[0]);
            for (String cur : strArr)
                outputStream.println(cur);
        } finally {
            if (reader  != null) {
                inputStream.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
        }
    }

}

import java.io.IOException;
import java.nio.file.*;
import java.util.function.Function;
import java.util.stream.Stream;

public class FileSortWithStreams {

    public static void main(String[] args) throws IOException {
        Path initialFile = Paths.get("files/initial.txt");
        Path sortedFile = Paths.get("files/sorted.txt");

        Stream<CharSequence> sortedLines = Files.lines(initialFile).sorted().map(Function.identity());

        Files.write(sortedFile, sortedLines::iterator, StandardOpenOption.CREATE);
    }
}