Java 将.txt文件解析为不同的数组

我有不同数据的.txt文件。所有这些数据组织为3类。我需要为第一个阵列获取一些数据，一些用于第二个阵列，另一个用于第三个阵列。如何做到这一点

txt文件包含第X部分、空格和#（用于将文本与第2类和第3类分开）

同时，我需要从每个类别收集数据： 第1部分和第3部分，第2部分和第4部分#

现在我陷入困境，我的代码获取了所有数据，我不知道下一步该怎么做

public class MainActivity extends AppCompatActivity {

    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = (TextView) findViewById(R.id.text1);
        textView.setMovementMethod(new ScrollingMovementMethod());
        String data = "";
        StringBuffer sBuffer = new StringBuffer();
        InputStream is = this.getResources().openRawResource(R.raw.phrases);
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));

        if ( is!= null){
            try {
                while ((data=reader.readLine()) !=null){
                    sBuffer.append(data + "\n");
                }
                textView.setText(sBuffer);
                is.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

---

您应该在while循环中添加您的解析逻辑，在该循环中，您每次迭代读取一行

您可以在循环中执行以下操作：

String[] parsedData = new String[3];
int parsingBlock = -1;
while ((data=reader.readLine()) !=null) {
    if (parsingBlock >= 0) {
        switch (parsingBlock) {
            case 0: parsedData[0] = data; break;
            case 1: {
                String [] part2Data = data.split("#");
                parsedData[1] = part2Data[0];
                parsedData[2] = part2Data[1];
                break;
            }
            case 2: parsedData[0] = parsedData[0] + data; break;
            case 3: {
                String [] part4Data = data.split("#");
                parsedData[1] = parsedData[1] + part4Data[0];
                parsedData[2] = parsedData[2] + part4Data[1];
            }
            default: break;
        }
    }
    parsingBlock = -1;
    if (data.equals("part 1")) {
        parsingBlock = 0;
    } else if (data.equals("part 2")) {
        parsingBlock = 1;
    } else if (data.equals("part 3")) {
        parsingBlock = 2;
    } else if (data.equals("part 4")) {
        parsingBlock = 3;
    }
}

---

您应该在while循环中添加您的解析逻辑，在该循环中，您每次迭代读取一行

您可以在循环中执行以下操作：

String[] parsedData = new String[3];
int parsingBlock = -1;
while ((data=reader.readLine()) !=null) {
    if (parsingBlock >= 0) {
        switch (parsingBlock) {
            case 0: parsedData[0] = data; break;
            case 1: {
                String [] part2Data = data.split("#");
                parsedData[1] = part2Data[0];
                parsedData[2] = part2Data[1];
                break;
            }
            case 2: parsedData[0] = parsedData[0] + data; break;
            case 3: {
                String [] part4Data = data.split("#");
                parsedData[1] = parsedData[1] + part4Data[0];
                parsedData[2] = parsedData[2] + part4Data[1];
            }
            default: break;
        }
    }
    parsingBlock = -1;
    if (data.equals("part 1")) {
        parsingBlock = 0;
    } else if (data.equals("part 2")) {
        parsingBlock = 1;
    } else if (data.equals("part 3")) {
        parsingBlock = 2;
    } else if (data.equals("part 4")) {
        parsingBlock = 3;
    }
}

---

下面是使用StringBuffer的内容执行此操作的一种方法：

List<String> arr1 = new ArrayList<>();
List<String> arr2 = new ArrayList<>();
List<String> arr3 = new ArrayList<>();
Pattern p = Pattern.compile("part \\d+\\n(.*)\\n+part \\d+\\n(.*)#(.*)");
Matcher m = p.matcher(sBuffer);
while(m.find()) {
    arr1.add(m.group(1));
    arr2.add(m.group(2));
    arr3.add(m.group(3));
}

List arr1=new ArrayList（）；
List arr2=新的ArrayList（）；
List arr3=新的ArrayList（）；
模式p=Pattern.compile（“part\\d+\\n（.*）\\n+part\\d+\\n（.*））；
匹配器m=p.Matcher（sBuffer）；
while（m.find（））{
arr1.添加（m.组（1））；
arr2.添加（m.组（2））；
arr3.添加（m.组（3））；
}

---

注意：在上面的代码中，为了方便起见，我使用了ArrayList而不是arrays。但是，您可以通过使用myList.toArray（新字符串[0]）

轻松地将

列表

转换为

字符串[]

数组。以下是使用StringBuffer的内容执行此操作的一种方法：

List<String> arr1 = new ArrayList<>();
List<String> arr2 = new ArrayList<>();
List<String> arr3 = new ArrayList<>();
Pattern p = Pattern.compile("part \\d+\\n(.*)\\n+part \\d+\\n(.*)#(.*)");
Matcher m = p.matcher(sBuffer);
while(m.find()) {
    arr1.add(m.group(1));
    arr2.add(m.group(2));
    arr3.add(m.group(3));
}

List arr1=new ArrayList（）；
List arr2=新的ArrayList（）；
List arr3=新的ArrayList（）；
模式p=Pattern.compile（“part\\d+\\n（.*）\\n+part\\d+\\n（.*））；
匹配器m=p.Matcher（sBuffer）；
while（m.find（））{
arr1.添加（m.组（1））；
arr2.添加（m.组（2））；
arr3.添加（m.组（3））；
}

---

注意：在上面的代码中，为了方便起见，我使用了ArrayList而不是arrays。但是，您可以使用myList.toArray（新字符串[0]）轻松地将

列表

转换为

字符串[]

数组您的问题不完整，您的文件格式规范是什么？您的文件是否真的包含

partX

和空行？目前，您似乎只将每一行读取到StringBuffer，但我们仍然不知道是什么阻止您将这些行（或拆分后的部分行）放入数组。您的问题不完整，您的文件格式规范是什么？您的文件是否真的包含

partX

和空行？目前看来，您只将每一行读取到StringBuffer，但我们仍然不知道是什么阻止您将这些行（或拆分后的部分行）放入数组。