如何保存删除字符与StringBuilder的

Question

是否有可能挽救这是与StringBuffer的删除字符或删除所有字符，除了一个在“我”指数 这是一个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"); 
    } 
} 

Answer 1

我想你可能是过于复杂的事情。你可以流式处理文件的行，解析它们，并将它们映射到偶数的总和。那么你可以去和的阵列上，找到最大元素的索引（这也可以用流做，只是为了好玩）：

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();