【问题标题】:Effective way to read file and parse each line读取文件和解析每一行的有效方法
【发布时间】:2017-03-06 18:01:41
【问题描述】:

我有一个下一个格式的文本文件:每一行都以一个字符串开头,后面跟着一个数字序列。每行的长度未知(数字数量未知,数量从 0 到 1000)。

string_1 3 90 12 0 3
string_2 49 0 12 94 13 8 38 1 95 3
.......
string_n 9 43

之后我必须使用handleLine 方法处理每一行,该方法接受两个参数:字符串名称和数字集(参见下面的代码)。

如何有效地读取文件并使用handleLine 处理每一行?

我的解决方法:

  1. 使用java8流Files.lines逐行读取文件。 它会阻塞吗?
  2. 用正则表达式分割每一行
  3. 将每一行转换为标题字符串和一组数字

我认为由于第 2 步和第 3 步,它非常无效。第一步意味着java首先将文件字节转换为字符串,然后在第二步和第三步中将它们转换回String/Set<Integer>。 这对性能有很大影响吗?如果是 - 如何做得更好?

public handleFile(String filePath) {
    try (Stream<String> stream = Files.lines(Paths.get(filePath))) {
        stream.forEach(this::indexLine);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private void handleLine(String line) {
    List<String> resultList = this.parse(line);
    String string_i = resultList.remove(0);
    Set<Integer> numbers = resultList.stream().map(Integer::valueOf).collect(Collectors.toSet());
    handleLine(string_i, numbers); // Here is te final computation which must to be done only with string_i & numbers arguments
}

private List<String> parse(String str) {
    List<String> output = new LinkedList<String>();
    Matcher match = Pattern.compile("[0-9]+|[a-z]+|[A-Z]+").matcher(str);
    while (match.find()) {
        output.add(match.group());
    }
    return output;
}

【问题讨论】:

  • 正如建议,也许将 Pattern.compile 移到此方法之外,我认为您不需要为每一行编译相同的模式。

标签: java nio java-io


【解决方案1】:

关于您的第一个问题,这取决于您如何引用Stream。 Streams 天生就是懒惰的,如果你不打算使用它就不要工作。例如,对Files.lines 的调用实际上不会读取文件,直到您在Stream 上添加终端操作。

来自 java 文档:

从文件中读取所有行作为流。与 readAllLines 不同,此方法不会将所有行读取到 List 中,而是在使用流时延迟填充

forEach(Consumer&lt;T&gt;) 调用是一个终端操作,此时,文件的行会被一一读取并传递给您的 indexLine 方法。

关于您的其他 cmets,您在这里真的没有问题。你想测量/最小化什么?仅仅因为某事是多个步骤并不固有地使其性能不佳。即使您创建了一个 wizbang oneliner 以将 File 字节直接转换为您的 String 和 Set,您也可能只是匿名进行了中间映射,或者您调用了一些会导致编译器执行此操作的东西.

【讨论】:

    【解决方案2】:

    这是您将行解析为名称和数字的代码

    stream.forEach(line -> {
        String[] split = line.split("\\b"); //split with blank seperator
        Set<String> numbers = IntStream.range(1, split.length)
                                    .mapToObj(index -> split[index])
                                    .filter(str -> str.matches("\\d+")) //filter numbers
                                    .collect(Collectors.toSet());
        handleLine(split[0], numbers);
    });
    

    或者其他方式

    Map<Boolean, List<String>> collect = Pattern.compile("\\b")
                                                .splitAsStream(line)
                                                .filter(str -> !str.matches("\\b"))
                                                .collect(Collectors.groupingBy(str -> str.matches("\\d+")));
    handleLine(collect.get(Boolean.FALSE).get(0), collect.get(Boolean.TRUE));
    

    【讨论】:

      【解决方案3】:

      我开始测试几种解决此问题的方法,并在指定条件下尽可能地衡量性能。以下是我测试的内容和测试方式,以及随附的结果:

      import java.io.BufferedReader;
      import java.io.FileReader;
      import java.io.IOException;
      import java.nio.file.Files;
      import java.nio.file.Paths;
      import java.util.ArrayList;
      import java.util.LinkedList;
      import java.util.List;
      import java.util.Random;
      import java.util.Scanner;
      import java.util.Set;
      import java.util.stream.Collectors;
      import java.util.stream.IntStream;
      import java.util.stream.Stream;
      
      public class App {
      
          public static void method1(String testFile) {
              List<Integer> nums = null;
              try (Scanner s = new Scanner(Paths.get(testFile))) {
                  while (s.hasNext()) {
                      if (s.hasNextInt())
                          nums.add(s.nextInt());
                      else {
                          nums = new ArrayList<Integer>();
                          String pre = s.next();
                          // handleLine( s.next() ... nums ... );
                      }
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method2(String testFile) {
              List<Integer> nums = null;
              try (BufferedReader in = new BufferedReader(new FileReader(testFile));
                      Scanner s = new Scanner(in)) {
                  while (s.hasNext()) {
                      if (s.hasNextInt())
                          nums.add(s.nextInt());
                      else {
                          nums = new ArrayList<Integer>();
                          String pre = s.next();
                          // handleLine( s.next() ... nums ... );
                      }
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method3(String testFile) {
              List<Integer> nums = null;
              try (BufferedReader br = new BufferedReader(new FileReader(testFile))) {
                  String line = null;
                  while ((line = br.readLine()) != null) {
                      String[] arr = line.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.valueOf(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method3_1(String testFile) {
              List<Integer> nums = null;
              try (BufferedReader br = new BufferedReader(new FileReader(testFile))) {
                  String line = null;
                  while ((line = br.readLine()) != null) {
                      String[] arr = line.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.parseInt(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method4(String testFile) {
              List<Integer> nums = null;
              try {
                  List<String> lines = Files.readAllLines(Paths.get(testFile));
                  for (String s : lines) {
                      String[] arr = s.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.valueOf(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method4_1(String testFile) {
              List<Integer> nums = null;
              try {
                  List<String> lines = Files.readAllLines(Paths.get(testFile));
                  for (String s : lines) {
                      String[] arr = s.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.parseInt(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method5(String testFile) {
              List<Integer> nums = null;
              try (BufferedReader br = Files.newBufferedReader(Paths.get(testFile))) {
                  List<String> lines = br.lines().collect(Collectors.toList());
                  for (String s : lines) {
                      String[] arr = s.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.valueOf(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method5_1(String testFile) {
              List<Integer> nums = null;
              try (BufferedReader br = Files.newBufferedReader(Paths.get(testFile))) {
                  List<String> lines = br.lines().collect(Collectors.toList());
                  for (String s : lines) {
                      String[] arr = s.split(" ");
                      nums = new ArrayList<Integer>();
                      for (int i = 1; i < arr.length; ++i)
                          nums.add(Integer.parseInt(arr[i]));
                      // handleLine( ... );
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void method6(String testFile) {
              List<Integer> nums = new LinkedList<Integer>();
              try (Stream<String> stream = Files.lines(Paths.get(testFile))) {
                  stream.forEach(line -> {
                      String[] split = line.split("\\b"); // split with blank seperator
                      Set<String> numbers = IntStream.range(1, split.length)
                              .mapToObj(index -> split[index])
                              .filter(str -> str.matches("\\d+")) // filter numbers
                              .collect(Collectors.toSet());
                      numbers.forEach((k) -> nums.add(Integer.parseInt(k)));
                      // handleLine( ... );
                  });
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
          public static void main(String[] args) throws Exception {
      
              args = new String[] { "C:\\Users\\Nick\\Desktop\\test.txt" };
      
              Random r = new Random();
      
              System.out.println("warming up a little...");
              for (int i = 0; i < 100000; ++i) {
                  int x = r.nextInt();
              }
      
              long s1 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method1(args[0]);
              long e1 = System.currentTimeMillis();
      
              long s2 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method2(args[0]);
              long e2 = System.currentTimeMillis();
      
              long s3 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method3(args[0]);
              long e3 = System.currentTimeMillis();
      
              long s3_1 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method3_1(args[0]);
              long e3_1 = System.currentTimeMillis();
      
              long s4 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method4(args[0]);
              long e4 = System.currentTimeMillis();
      
              long s4_1 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method4_1(args[0]);
              long e4_1 = System.currentTimeMillis();
      
              long s5 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method5(args[0]);
              long e5 = System.currentTimeMillis();
      
              long s5_1 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method5_1(args[0]);
              long e5_1 = System.currentTimeMillis();
      
              long s6 = System.currentTimeMillis();
              for (int i = 0; i < 10000; ++i)
                  method6(args[0]);
              long e6 = System.currentTimeMillis();
      
              System.out.println("method 1 = " + (e1 - s1) + " ms");
              System.out.println("method 2 = " + (e2 - s2) + " ms");
              System.out.println("method 3 = " + (e3 - s3) + " ms");
              System.out.println("method 3_1 = " + (e3_1 - s3_1) + " ms");
              System.out.println("method 4 = " + (e4 - s4) + " ms");
              System.out.println("method 4_1 = " + (e4_1 - s4_1) + " ms");
              System.out.println("method 5 = " + (e5 - s5) + " ms");
              System.out.println("method 5_1 = " + (e5_1 - s5_1) + " ms");
              System.out.println("method 6 = " + (e6 - s6) + " ms");
          }
      }
      
      • 用于 java.version = 1.8.0_101 (Oracle)
      • x64 操作系统/处理器

      结果输出:

      warming up a little...
      method 1 = 1103 ms
      method 2 = 872 ms
      method 3 = 440 ms
      method 3_1 = 418 ms
      method 4 = 413 ms
      method 4_1 = 376 ms
      method 5 = 439 ms
      method 5_1 = 384 ms
      method 6 = 646 ms
      

      据我了解,我测试的样本中最好的方法是使用Files.readAllLines、s.split(" ") 和Integer.parseInt。这三个组合再次产生了明显最快的,在我创建和测试的样本中至少您可能会更改为Integer.parseInt 以提供一些帮助。

      注意,我使用资源来帮助获得一些广受欢迎的方法,并将它们应用于这个问题/示例。例如。 this blog post,this tutorial,还有这个了不起的家伙@Peter-Lawrey。此外,可以随时进行进一步改进!

      另外,test.txt 文件:

      my_name 15 00 29 101 1234
      cool_id 11 00 01 10 010101
      longer_id_name 1234
      dynamic_er 1 2 3 4 5 6 7 8 9 10 11 12 123 1456 15689 555555555
      

      (注意:性能可能因文件大小而有很大差异!)

      【讨论】:

        猜你喜欢
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2018-12-31
        • 1970-01-01
        • 1970-01-01
        • 1970-01-01
        • 2021-12-29
        • 2012-07-04
        相关资源
        最近更新 更多