Java 使用新行拆分并存储在数据结构中

我有如下文本文件数据：

2,2,1

数据1123,89,1
数据2124,90,2
数据3125,91,3
数据4126,92,4

数据5127,93,5
数据6128,94,6
数据7129,95,7

数据8130,96,8
数据9131,97,9
数据10132,98,10

第一行2,2,1表示第一组行中的2行并将其存储在节点文件中，第二组行中的2行将其存储在链接文件中，第三组行中的1行将其存储在模块文件中。然而，例如，我显示了少量的行，但它是一个较大的文件

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class ReadFile {
    static List<String> moduleFile = new ArrayList<>();
    static List<String> linkFile = new ArrayList<>();
    static List<String> nodeFile = new ArrayList<>();
    static int a[];
    public static void main(String[] args) {
        File file11 = new File("/home/madhu/Desktop/node.txt");
        Scanner scAll = null;
        try {
            scAll = new Scanner(file11);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        String[] numberOfLines = (scAll.nextLine()).split(",");

        int flag = 0;
        int counter = 1;
        while (scAll.hasNext()) {
            if (flag == 0 && "\\n\\n".equals(scAll.nextLine()) && counter <= Integer.parseInt(numberOfLines[0].trim())) {
                for (int i = 0; i < Integer.parseInt(numberOfLines[0].trim()); i++) {
                    System.out.println(scAll.nextLine());
                    nodeFile.add(scAll.nextLine());
                    counter++;
                }
                if (counter > Integer.parseInt(numberOfLines[0].trim())) {
                    flag = 1;
                    counter = 1;
                }

            } else if (flag == 1 && "\\n\\n".equals(scAll.nextLine())
                && counter <= Integer.parseInt(numberOfLines[1].trim())) {
                for (int i = 0; i < Integer.parseInt(numberOfLines[1].trim()); i++) {
                    System.out.println(scAll.nextLine());
                    linkFile.add(scAll.nextLine());
                    counter++;
                }
                if (counter > Integer.parseInt(numberOfLines[1].trim())) {
                    flag = 2;
                    counter = 1;
                }

                } else if (flag == 2 && "\\n\\n".equals(scAll.nextLine())
                && counter <= Integer.parseInt(numberOfLines[2].trim())) {
                    for (int i = 0; i < Integer.parseInt(numberOfLines[2].trim()); i++) {
                    System.out.println(scAll.nextLine());
                    moduleFile.add(scAll.nextLine());
                    counter++;
                }

            } else {
                continue;
            }
        }
        scAll.close();


    }


    }

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Scanner；
公共类读取文件{
静态列表moduleFile=new ArrayList（）；
静态列表链接文件=新的ArrayList（）；
静态列表节点文件=新的ArrayList（）；
静态int a[]；
公共静态void main（字符串[]args）{
File file11=新文件（“/home/madhu/Desktop/node.txt”）；
scAll=null；
试一试{
scAll=新扫描仪（文件11）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}
字符串[]numberOfLines=（scAll.nextLine（））.split（“，”）；
int标志=0；
int计数器=1；
while（scAll.hasNext（））{
if（flag==0&&“\\n\\n”.equals（scAll.nextLine（））&&counter Integer.parseInt（numberOfLines[0].trim（））{
flag=1；
计数器=1；
}
}else if（flag==1&&“\\n\\n”.equals（scAll.nextLine（））
&&计数器整数.parseInt（numberOfLines[1].trim（））{
flag=2；
计数器=1；
}
}else if（flag==2&&“\\n\\n”.equals（scAll.nextLine（））
&&希望我没有误解，但我会这么做

我并没有检查这个示例是否完全有效，但它应该或多或少有效

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

class ReadFile {
    // basically just do what you did
    static List<String> nodeFile;
    static List<String> linkFile;
    static List<String> moduleFile;

    public static void main(String[] args) throws FileNotFoundException {
        final File file = new File("/home/madhu/Desktop/node.txt");
        final Scanner scanner = new Scanner(file);

        // make it a little better for indexing
        final List<Integer> selections = Arrays
                .stream(scanner.nextLine().split(","))
                .map(Integer::parseInt)
                .collect(Collectors.toList());

        // this is the meat of the code
        // basically each split up block of lines is a block
        final List<List<String>> blocks = new ArrayList<>();
        while (scanner.hasNextLine()) {
            List<String> lines = new ArrayList<>();
            String line;
            while (!(line = scanner.nextLine()).equals("\n")) {
                lines.add(line);
            }
            if (!lines.isEmpty()) {
                blocks.add(lines);
            }
        }

        // allocate your files now
        nodeFile = blocks.get(0).subList(0, selections.get(0));
        linkFile = blocks.get(1).subList(0, selections.get(1));
        moduleFile = blocks.get(2).subList(0, selections.get(2));

        scanner.close();
    }
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.Scanner；
导入java.util.stream.collector；
类读取文件{
//基本上就是做你所做的
静态列表节点文件；
静态列表链接文件；
静态列表模块文件；
公共静态void main（字符串[]args）引发FileNotFoundException{
最终文件=新文件（“/home/madhu/Desktop/node.txt”）；
最终扫描仪=新扫描仪（文件）；
//为索引做得更好一点
最终列表选择=数组
.stream（scanner.nextLine（）.split（“，”））
.map（整数：：parseInt）
.collect（Collectors.toList（））；
//这是代码的核心
//基本上，每个分割的线块都是一个块
最终列表块=新的ArrayList（）；
while（scanner.hasNextLine（））{
列表行=新的ArrayList（）；
弦线；
而（！（line=scanner.nextLine（））.equals（“\n”））{
行。添加（行）；
}
如果（！lines.isEmpty（））{
块。添加（行）；
}
}
//现在分配您的文件
nodeFile=blocks.get（0）.subList（0，selections.get（0））；
linkFile=blocks.get（1）.subList（0，selections.get（1））；
moduleFile=blocks.get（2）.子列表（0，selections.get（2））；
scanner.close（）；
}
}
试试这段代码，我使用了BufferedReader，因为它更干净：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReadFile {

    static List<String> moduleFile = new ArrayList<>();
    static List<String> linkFile = new ArrayList<>();
    static List<String> nodeFile = new ArrayList<>();

    public static void main(String[] args) {
        File file = new File("/home/madhu/Desktop/node.txt");
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));
            String data[] = reader.readLine().split(",");
            String s;
            int nbline=0, i=0,block =0;
            while ((s = reader.readLine())!=null && block < data.length) {
                if(s.equals("")){ 
                    block++;
                    nbline = Integer.parseInt(data[block-1]);
                    i = 0;
                }
                for(;i<nbline;i++){
                    s = reader.readLine();
                    if(s == null) break;
                    else if(s.equals("")){
                        block++;
                        break;
                    }
                    switch(block){
                        case 1 :
                            nodeFile.add(s);
                            break;
                        case 2:
                            linkFile.add(s);
                            break;
                        default: moduleFile.add(s);
                    }
                }
            }

        } catch (IOException | NumberFormatException ex) {
            System.err.println(ex.getStackTrace());
        } 
        finally{
            closeReader(reader);
        }
        
        System.out.println("nodeFile : "+nodeFile);
        System.out.println("linkFile : "+linkFile);
        System.out.println("moduleFile : "+moduleFile);
    }

    public static void closeReader(BufferedReader reader) {
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
            }
        }
    }

}

while（！（line=scanner.nextLine（））.equals（“\n”））我在这一行遇到错误。错误：找不到行。请检查@AllicsAh是的，对不起@Madhusmita Sahoo。您需要执行以下操作：
while（scanner.hasNextLine（）&！（line=scanner.nextLine（））.equals（“\n”））{
在那一行改为.hiii，我得到了错误：linkFile=blocks.get（1）处长度1的索引1超出了界限。子列表（0，selections.get（1））请检查“AliicsThis”可能意味着空白行不只是一个简单的新行字符。您可能要通过打印<代码> Bug < /C>的内容来确认这一点。当终止时，您能看到任何错误吗？再来一个帮助！如果我想将NODFILE数据存储到字符串数组中，如字符串ST（1）。= DATA1123，891，和ST（2）= DATA212490.2.HW，我可以这样做，因为当它分裂时也[]简单地写“代码>字符串ST1= NoDeFiel.ToAlayy（））/>代码，如果有帮助的话，请考虑接受答案。
nodeFile : [data1,123,89,1, data2,124,90,2]
linkFile : [data5,127,93,5, data6,128,94,6]
moduleFile : [data8,130,96,8]