Question

我有以下文本文件（answers.txt）：

问题A：23 | 47 | 32 | 20

问题B：40 | 50 | 30 | 45

问题C：5 | 8 | 11 | 14

问题D：20 | 23 | 25 | 30

我需要的是能够解读我告诉它的问题（问题A，问题B），然后读取它后面的数字，这些数字由行分隔，然后将其打印出来：

问题A的答案：a.23 b.47 c.32 d.20

有谁知道如何做到这一点？我已经坚持了一段时间。

Answer 1

逐行读取行，首先将行拆分为“”。您将获得一个包含“问题”，“A：”和“23 | 47 | 32 | 20”三部分的数组。然后将第三部分拆分为“|”所以你将获得第二个阵列，其中有四个部分“23”，47“，”32“，”20“。

将all组合以获得所需的输出。

如果您想了解如何从文件中读取行或溢出字符串的信息，那么有数十亿的在线教程如何做到这一点，所以我不会详细介绍它是如何完成的。我确定你可以找到它们。

Answer 2

查看此代码！它假设您有这样的文件格式：

Problem A:
23|7|32|20
Problem B:
40|50|30|45
Problem C:
5|8|11|14
Problem D:
20|23|25|30

因为你写了“之后用数字分隔的数字”

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

public class Demo {

public static void main(String[] args) throws FileNotFoundException {
    Scanner sc = new Scanner(new File("answers.txt"));
    List<String> dataList = new ArrayList<String>();
    while(sc.hasNextLine()){
        dataList.add(sc.nextLine());
    }
    System.out.println(dataList);       
    Map<String,String> map = new HashMap<String,String>();
    for(int i=0;i<dataList.size();i=i+2){
        map.put(dataList.get(i),dataList.get(i+1));
    }

    for(Entry<String,String> en:map.entrySet()){
        System.out.println(en.getKey()+" : "+en.getValue());
    }
    String problemC = map.get("Problem C:");
    String splitted[] = problemC.split("\\|");
    System.out.println("Get me problem C: "+String.format("a:%s, b:%s, c:%s, d:%s",splitted[0],splitted[1],splitted[2],splitted[3]));
}

}

Answer 3

希望这有帮助！

    public static void main(String args[])
{
    BufferedReader br = new BufferedReader(new FileReader(new File("answers.txt")));
    String lineRead  = null;
    String problem = "Problem A";//Get this from user Input
    List<String> numberData = new ArrayList<String>();
    while((lineRead = br.readLine())!=null)
    {
        if(lineRead.contains(problem))
        {
            StringTokenizer st = new StringTokenizer(lineRead,":");
            String problemPart = st.nextToken();
            String numbersPart = st.nextToken();
            st = new StringTokenizer(lineRead,"|");
            while(st.hasMoreTokens())
            {
                String number = st.nextToken();
                System.out.println("Number is: " + number);
                numberData.add(number);
            }
            break;
        }
    }
    System.out.println("Answers for " + problem + " : " + numberData );
}

Answer 4

逐行阅读这些行，用:分割这些行。您将获得一个包含“问题A：”和“23 | 47 | 32 | 20”两部分的数组。然后将第二部分拆分为“|”所以你将获得第二个阵列，其中有四个部分“23”，47“，”32“，”20“。

结合所有这些，你将得到你想要的输出。

干杯！

Answer 5

使用java.util.Scanner，您可以过滤文件中的整数。

Scanner s = new Scanner (new File ("answers.txt")).useDelimiter("\\s+");
while (s.hasNext()) {
    if (s.hasNextInt()) { // check if next token is integer
        System.out.print(s.nextInt());
    } else {
        s.next(); // else read the next token
    }
}

Answer 6

你知道如何逐行阅读吗？如果没有，请将其How to read a large text file line by line in java?

要提交字符串数据，有很多方法可以做。您可以按照自己的意愿分组。这是我的代码..

    String data = yourReader.readLine();
    String problem = data.substring("Problem".length(), data.indexOf(":"));
    System.err.println("Problem is " + problem);
    data = data.substring(data.indexOf(":") + 2, data.length());
    String[] temp = data.split("\\|");
    for (String result : temp) {
        System.out.println(result);
    }

Answer 7

假设您的示例中总有四个可能的答案：

// read complete file in fileAsString
String regex = "^(Problem \\w+): (\\d+)\\|(\\d+)\\|(\\d+)\\|(\\d+)$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(fileAsString);
//and so on, read all the Problems using matcher.find() and matcher.group(int) to get the parts
// put in a Map  maybe?
// output the one you want...

Answer 8

我可能会建议为组织目的创建一个简单的数据类型：

public class ProblemAnswer {
  private final String problem;
  private final String[] answers;

  public ProblemAnswer(String problem, String[] answers) {
    this.problem = problem;
    this.answers = new String[answers.length];
    for (int i = 0; i < answers.length; i++) {
      this.answers[i] = answers[i];
    }
  }

  public String getProblem() {
    return this.problem;
  }

  public String[] getAnswers() {
    return this.answers;
  }

  public String getA() {
    return this.answers[0];
  }

  public String getB() {
    return this.answers[1];
  }

  public String getC() {
    return this.answers[2];
  }

  public String getD() {
    return this.answers[3];
  }
}

然后从文本文件中读取的内容如下所示：

public void read() {
  Scanner s = new Scanner("answers.txt");
  ArrayList<String> lines = new ArrayList<String>();
  while (s.hasNext()) {
    lines.add(s.nextLine());//first separate by line  
  }
  ProblemAnswer[] answerKey = new ProblemAnswer[lines.size()];
  for (int i = 0; i < lines.size(); i++) {
    String[] divide = lines.get(i).split(": "); //0 is the problem name, 1 is the list                 
                                                //of answers
    String[] answers = divide[1].split("|");  //an array of the answers to a given
                                              //question
    answerKey[i] = new ProblemAnswer(divide[0], answers); //add a new ProblemAnswer 
                                                          //object to the key
  }
}

现在为您提供了一个可以轻松检查的ProblemAnswer对象的答案键通过对.equals()方法的简单getProblem()比较，以及匹配的索引，您可以将所有答案整齐地排列在同一个对象中。

如何在文本文件中查找某些单词，然后在Java中查找数字？

8 个答案: