JAVA : 文件 I/O

Question

我有两个包含以下格式数据的文本文件

data.txt 文件格式如下

A 10
B 20
C 15

data1.txt文件格式（起始节点，结束节点，距离）：

A B 5 
A C 10
B C 20

我正在尝试实施搜索策略，因为我需要从 data.txt 加载数据，并且只需要从 data1.txt 加载起始节点和结束节点（即我不需要距离） .我需要将这些信息存储在堆栈中，因为我认为这将是实现贪婪搜索的最佳数据结构。

实际上我不确定如何开始使用文件 I/O 来读取这些文件并将它们存储在数组中以实现贪婪搜索。所以我非常感谢任何关于如何进行的初步想法。

我是新手，所以请多多包涵。任何帮助深表感谢。谢谢。

编辑：这是我到目前为止得到的

String heuristic_file = "data.txt";
try
    {          

        FileReader inputHeuristic = new FileReader(heuristic_file);
        BufferedReader bufferReader = new BufferedReader(inputHeuristic);
        String line;

        while ((line = bufferReader.readLine()) != null)   
        {
            System.out.println(line);
        }

        bufferReader.close(); 

    } catch(Exception e) {
        System.out.println("Error reading file " + e.getMessage());
    }

Answer 1

使用拆分

            while ((line = bufferReader.readLine()) != null)   
            {
                String[] tokens = line.split(" ");
                System.out.println(line + " -> [" + tokens[0] + "]" + "[" + tokens[1] + "][" + tokens[2] + "]");
            }

如果你必须把它放在一个数组中，你可以使用下面的：

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

public class NodeTest {

  public static void main(String[] args) throws ParseException {
    try {          
      File first = new File("data.txt");
      File second = new File("data1.txt");    

      Node[] nodes1 =  getNodes(first);
      Node[] nodes2 =  getNodes(second);

      print(nodes1);
      print(nodes2);
    } 
    catch(Exception e) {
      System.out.println("Error reading file " + e.getMessage());
    }   
  }

  public static final void print(Node[] nodes) {
    System.out.println("======================");
    for(Node node : nodes) {
      System.out.println(node);
    }
    System.out.println("======================");
  }

  public static final Node[] getNodes(File file) throws IOException {
    FileReader inputHeuristic = new FileReader(file);
    BufferedReader bufferReader = new BufferedReader(inputHeuristic);
    String line;
    List<Node> list = new ArrayList<Node>();
    while ((line = bufferReader.readLine()) != null) {
      String[] tokens = line.split(" ");
      list.add(new Node(tokens[0], tokens[1]));               
    }
    bufferReader.close(); 
    return list.toArray(new Node[list.size()]);
  } 
}

class Node {
  String start;
  String end;

  public Node(String start, String end){
    this.start = start;
    this.end = end;
  }

  public String toString() {
    return "[" + start + "][" + end + "]";
  }
}

Answer 2

是这样的吗？

HashSet<String> nodes = new HashSet<String>();
try(BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line = br.readLine();
    while (line != null) {
        String[] l = line.split(" ");
        nodes.add(l[0]);
        line = br.readLine();
    }
}

try(BufferedReader br = new BufferedReader(new FileReader("data1.txt"))) {
    String line = br.readLine();
    while (line != null) {
        String[] l = line.split(" ");
        if (nodes.contains(l[0]) || nodes.contains(l[1]))
            // Do whatever you want ...
        line = br.readLine();
    }
}

Answer 3

我的方法与其他方法没有根本区别。请注意 try/catch/finally 块。始终将关闭语句放在 finally 块中，因此即使在读取文件时抛出异常，也可以保证打开的文件被关闭。

两者之间的部分 //[...] 肯定可以做得更有效率。也许一次读取整个文件然后向后解析文本并搜索换行符？也许一个 Stream-API 支持设置阅读位置。老实说，我不知道。到目前为止，我不需要那个。

我选择使用 BufferedReader 的详细初始化，因为这样您就可以指定文件的预期编码。在你的情况下没关系，因为你的文件不包含超出标准 ASCII 范围的符号，但我相信这是半最佳实践。

在您提问之前：r.close() 负责以正确的顺序关闭基础 InputStreamReader 和 FileInputStream，直到所有读取器和流都关闭。

public static void readDataFile(String dir, String file1, String file2)
    throws IOException
{
    File datafile1 = new File(dir, file1);
    File datafile2 = new File(dir, file2);

    if (datafile1.exists())
    {
        BufferedReader r = null;

        try
        {
            r = new BufferedReader(
                new InputStreamReader(
                    new FileInputStream(datafile1),
                    "UTF-8"
                )
            );

            String row;

            Stack<Object[]> s = new Stack<Object[]>();
            String[] pair;
            Integer datapoint;

            while((row = r.readLine()) != null)
            {
                if (row != null && row.trim().length() > 0)
                {
                    // You could use " " instead of "\s"
                    // but the latter regular expression
                    // shorthand-character-class will
                    // split the row on tab-symbols, too
                    pair = row.split("\s");
                    if (pair != null && pair.length == 2)
                    {
                        datapoint = null;
                        try
                        {
                            datapoint = Integer.parseInt(pair[1], 10);
                        }
                        catch(NumberFormatException f) { }

                        // Later you can validate datapairs
                        // by using
                        // if (s.pop()[1] != null)
                        s.add(new Object[] { pair[0], datapoint});
                    }
                }
            }
       }
       catch (UnsupportedEncodingException e1) { }
       catch (FileNotFoundException e2) { }
       catch (IOException e3) { }
       finally
       {
           if (r != null) r.close();
       }
   }

   // Do something similar with datafile2
   if (datafile2.exists())
   {
       // [...do the same as in the first try/catch block...]

       String firstrow = null, lastrow = null;
       String row = null;
       int i = 0;
       do
       {
          lastrow = row;
          row = r.readLine();
          if (i == 0)
              firstrow = row;
          i++;
       } while(row != null);

       // [...parse firstrow and lastrow into a datastructure...]
   }
}

JAVA : 文件 I/O

JAVA : file I/O

java

file-io

greedy