Java 如何使用stringbuilder保存已删除的字符

是否可以保存使用Stringbuffer删除的字符，或删除除“i”索引上的字符以外的所有字符 这是我从txt文件中输入的内容：

3;8;4;5;3;2
3 4 5 1 2 3
9;8;3;2;3;4
9 8 9 7 8 1

我需要总结每一行，看看哪一行是偶数最多的，所以我决定读一整行，用空格分隔字符，然后在字符串生成器的帮助下删除除“I”位置的一个字符以外的所有字符，最后保存在二维数组中。 也许你会有更好的主意怎么做

我的代码：

package Operacje_na_plikach;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

public class Zad3 {
    /*
    Plik tekstowy ‘dane.txt’ ma postać:
3;8;4;5;3;2
3 4 5 1 2 3
9;8;3;2;3;4
9 8 9 7 8 1
Pobierz z pliku tekstowego kolejne wiersze liczb i wypisz na ekranie numer wiersza, w którym występuje najwięcej elementów parzystych.
     */
    public static String[][] odczyt(String nazwa)
    {
        String[][] arr = new String[1][1];
        int[] suma = new int[1];
        int max = -1;
        int wiersz=-1;
        String text = null;
        try {
            FileReader reader = new FileReader(nazwa);
            Scanner sc = new Scanner(reader);
            while(sc.hasNextLine())
            {
                arr=Arrays.copyOf(arr,arr.length+1);
                text = sc.nextLine().replaceAll(";"," ");
                int[] temp= new int[text.length()];
                StringBuilder sb = new StringBuilder(text);
                for (int i = 0; i <temp.length ; i++) {
                 temp[i]=sb.delete();
                }
                for (int i = 0; i < ; i++) {
                    for (int j = 0; j < ; j++) {
                        arr[i][j] = text
                    }
                }
            }

            /* while (sc.hasNextLine())
            {
                arr=Arrays.copyOf(arr,arr.length+1);
                text = sc.nextLine().replaceAll("[;]"," ");

                for (int i = 0; i <arr.length ; i++) {
                    while(text!=null)
                    {
                        int temp = Integer.parseInt(text);
                    }
                    for (int j = 0; j <arr.length ; j++) {

                        arr[i][j] = text.nextInt();
                        if(arr[i][j]%2==0)
                        {
                            suma[i]+=arr[i][j];
                            if(suma[i]>max)
                            {
                                max = suma[i];
                                wiersz=i;
                            }
                        }
                    }
                }
            }
            System.out.println("Najwiecej liczb parzystych jest w wierszu: " + wiersz);
*/



            sc.close();
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return arr;
    }

    public static void main(String[] args) {
        int[][] arr = odczyt("dane.txt");
    }
}

packageoperacje_na_plikach；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.array；
导入java.util.Scanner；
公共类Zad3{
/*
Plik tekstowy'dane.txt'ma postać：
3;8;4;5;3;2
3 4 5 1 2 3
9;8;3;2;3;4
9 8 9 7 8 1
波比尔兹·普利库·特克斯托伊戈·维尔泽·利茨比·维皮兹·纳埃克兰尼·维尔萨号，与帕济施蒂奇号元素相同。
*/
公共静态字符串[][]odczyt（字符串nazwa）
{
字符串[][]arr=新字符串[1][1]；
int[]suma=新int[1]；
int max=-1；
int-wiersz=-1；
字符串文本=空；
试一试{
FileReader=新的FileReader（nazwa）；
扫描仪sc=新扫描仪（读卡器）；
while（sc.hasNextLine（））
{
arr=Arrays.copyOf（arr，arr.length+1）；
text=sc.nextLine（）.replaceAll（“；”，”）；
int[]temp=new int[text.length（）]；
StringBuilder sb=新的StringBuilder（文本）；
对于（int i=0；i我认为您可能过于复杂了。您可以对文件的行进行流式处理，解析它们，并将它们映射到偶数的总和。然后您可以遍历总和数组，找到最大元素的索引（也可以使用流式处理，只是为了好玩）：

我认为您可能过于复杂了。您可以流式处理文件的行，解析它们，并将它们映射到偶数的总和。然后您可以遍历总和数组，找到最大元素的索引（也可以使用流进行索引，只是为了好玩）：

为了澄清-你希望这个文件的输出是什么？行数，其中偶数之和是最大的。为了澄清-你希望这个文件的输出是什么？行数，其中偶数之和是最大的。谢谢，但我按照你看到的方式做了，因为你的解决方案超出了我的能力。我正在学习我还没有学会java，我想我还远没有像你刚才那样解决问题。我的水平是：面向对象编程入门：D，但非常感谢！谢谢，但我是按照你看到的方式做的，因为你的解决方案超出了我的能力。我还在学java，我想我远没有像你刚才那样解决问题。我的水平是：面向对象编程入门面向ct的编程：D，但非常感谢！
long[] sums =
    Files.lines(Paths.get("dane.txt"))
         .mapToLong(s -> Arrays.stream(s.split("[ ;]"))
                               .mapToInt(Integer::parseInt)
                               .filter(i -> i % 2 == 0)
                               .sum())
         .toArray();

int lineNum =
    IntStream.range(0, sums.length)
             .boxed()
             .max(Comparator.comparingLong(i -> sums[i]))
             .get();