在 Java 中拆分字符串后尝试使用循环进行方法调用

你走在正确的轨道上。
首先需要将 [polynomial] 字符串拆分为项，其中项由加号分隔，即 .
请注意，这是一个正则表达式元字符，因此当您想将多项式的字符串拆分为项时，您需要对其进行转义。++

拆分为项后，您希望从每个项中提取系数和指数。
系数是 之前的数字，指数是 之后的数字。当然，术语可能不包含，也可能不包含，因此您也需要处理这些情况。
在下面的代码中，我使用方法 indexOf 来定位系数和指数，然后使用方法子字符串来提取它们。xx^x^

我不熟悉类，所以我假设它是你写的类，但是我在你的问题中找不到该类的代码，所以我写了自己的。在下面的代码中，是一个单向链表，其中列表中的每个节点都是类（这是我写的另一个类）的实例，并且 a 同时包含系数和指数。PolynomialPolynomialTermTerm

在下面的代码中，我从文本文件中读取一行，将其拆分为项，从每个项中提取系数和指数，创建一个实例并将其添加到实例中。
以下代码中的语句仅用于调试目的。TermPolynomialprint

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;

public class Proj2 {
    public static void poly() {
        try (BufferedReader br = Files.newBufferedReader(Paths.get("polynomials.txt"))) {
            String line = br.readLine();
            while (line != null) {
                Polynomial polynomial = new Polynomial();
                System.out.println(line);
                String[] terms = line.split("\\+");
                System.out.println(Arrays.toString(terms));
                boolean first = true;
                for (String term : terms) {
                    int begin = term.indexOf('^');
                    int exp;
                    if (begin > 1) {
                        exp = Integer.parseInt(term.substring(begin + 1));
                    }
                    else {
                        exp = 0;
                    }
                    int start = term.indexOf('x');
                    int coeff;
                    if (start == 0) {
                        coeff = 1;
                    }
                    else if (start > 0) {
                        coeff = Integer.parseInt(term.substring(0, start));
                    }
                    else {
                        coeff = Integer.parseInt(term);
                    }
                    if (first) {
                        first = false;
                    }
                    else {
                        System.out.print(", ");
                    }
                    System.out.printf("%d|%d", coeff, exp);
                    Term t = new Term(coeff, exp);
                    polynomial.addTerm(t);
                }
                System.out.println();
                System.out.println(polynomial);
                line = br.readLine();
            }
        }
        catch (IOException xIo) {
            xIo.printStackTrace();
        }
    }

    public static void main(String[] args) {
        poly();
    }
}

class Term {
    private final int  coefficient;
    private final int  exponent;
    private Term  next;

    public Term(int coeff, int exp) {
        coefficient = coeff;
        exponent = exp;
    }

    public Term getNext() {
        return next;
    }

    public void setNext(Term term) {
        next = term;
    }

    public String toString() {
        return String.format("%dx^%d%s",
                             coefficient,
                             exponent,
                             (next != null ? "+" : ""));
    }
}

class Polynomial {
    private Term  start;

    public void addTerm(Term term) {
        if (start == null) {
            start = term;
        }
        else {
            Term temp = start.getNext();
            Term last = start;
            while (temp != null) {
                last = temp;
                temp = temp.getNext();
            }
            last.setNext(term);
        }
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        Term temp = start;
        while (temp != null) {
            sb.append(temp);
            temp = temp.getNext();
        }
        return sb.toString();
    }
}

以下是在问题中使用示例多项式文件时的输出。

4x^2+2x^1+3
[4x^2, 2x^1, 3]
4|2, 2|1, 3|0
4x^2+2x^1+3x^0
5x^3+15
[5x^3, 15]
5|3, 15|0
5x^3+15x^0
2x^2+2x^1+5
[2x^2, 2x^1, 5]
2|2, 2|1, 5|0
2x^2+2x^1+5x^0

"...我怎样才能编写采用这两个术语并调用方法的代码......”

创建一个类来保存每个多项式项。

随后，创建一个静态方法来分析术语。

class Polynomial {
    BigDecimal coefficient;
    BigInteger power;

    static Polynomial parse(String s) {
        Polynomial p = new Polynomial();
        int i = s.indexOf('^');
        if (i == -1) p.coefficient = new BigDecimal(s);
        else {
            if (i != 1) p.coefficient = new BigDecimal(s.substring(0, i - 1));
            p.power = new BigInteger(s.substring(i + 1));
        }
        return p;
    }
}

从这里开始，使用二维 LinkedList 来包含每个多项式表达式。

LinkedList<LinkedList<Polynomial>> l = new LinkedList<>();
String f = "polynomials.txt";
try (BufferedReader r = new BufferedReader(new FileReader(f))) {
    String s;
    LinkedList<Polynomial> t;
    while ((s = r.readLine()) != null) {
        t = new LinkedList<>();
        for (String v : s.split("[+*-]")) t.add(Polynomial.parse(v));
        l.add(t);
    }
}

输出

coefficient = 4, power = 2
coefficient = 2, power = 1
coefficient = 3, power = null

coefficient = 5, power = 3
coefficient = 15, power = null

coefficient = 2, power = 2
coefficient = 2, power = 1
coefficient = 5, power = null