编程实现一元一次方程的求解（输入的方程式中不含括号及分号）。 如： 输入：3x+6=15 输出： 3.00 输入：-3+3x=13-x 输出： 4.00 输入：16-12a=128+24a-24 输出： -2.44 输入：x+8=x-8 输出：方程不成立，或x可等于任意值 输入：x-12=-12+x 输出：方程不成立，或x可等于任意值 请提交代码及测试运算结果。（提示：要对输入的方程字符串分割为多个列表项元素，部分字符要考虑替换）

以下是Java实现代码：

import java.util.regex.*;

public class EquationSolver {
    public static void main(String[] args) {
        System.out.println(solveEquation("3x+6=15"));  // 输出 3.0
        System.out.println(solveEquation("-3+3x=13-x"));  // 输出 4.0
        System.out.println(solveEquation("16-12a=128+24a-24"));  // 输出 -2.44
        System.out.println(solveEquation("x+8=x-8"));  // 输出 方程不成立，或x可等于任意值
        System.out.println(solveEquation("x-12=-12+x"));  // 输出 方程不成立，或x可等于任意值
    }

    public static String solveEquation(String equation) {
        // 将方程式拆分为左右两个部分
        String[] sides = equation.split("=");
        String left = sides[0].replaceAll("\\s", "");
        String right = sides[1].replaceAll("\\s", "");
        // 将左半部分拆分为系数和常数
        double[] leftCoeff = parseExpression(left);
        double leftCoef = leftCoeff[0];
        double leftConst = leftCoeff[1];
        // 将右半部分拆分为系数和常数
        double[] rightCoeff = parseExpression(right);
        double rightCoef = rightCoeff[0];
        double rightConst = rightCoeff[1];
        // 将等号移动到左边，并将常数移到右边
        double coef = leftCoef - rightCoef;
        double constVal = rightConst - leftConst;
        // 如果方程有解，则解为常数除以系数
        if (coef != 0) {
            double x = constVal / coef;
            return String.format("%.2f", x);
        } else if (constVal == 0) {
            // 如果方程无解，但常数为0，则x可取任意值
            return "方程不成立，或x可等于任意值";
        } else {
            // 如果方程无解且常数不为0，则方程无解
            return "方程不成立";
        }
    }

    public static double[] parseExpression(String expression) {
        // 匹配表达式中的数字和字母
        Matcher matcher = Pattern.compile("-?\\d+|[a-zA-Z]+").matcher(expression);
        // 如果表达式中只有一个变量，则系数为1
        if (!matcher.find()) {
            return new double[] {1.0, 0.0};
        }
        double coef = 0;
        double constVal = 0;
        // 遍历表达式中的每个项
        do {
            String token = matcher.group();
            // 如果是数字，则根据它前面的符号更新系数或常数
            if (token.matches("-?\\d+")) {
                if (matcher.start() > 0 && expression.charAt(matcher.start()-1) == '-') {
                    coef -= Double.parseDouble(token);
                } else {
                    coef += Double.parseDouble(token);
                }
            // 如果是字母，则根据它前面的符号更新系数
            } else if (token.matches("[a-zA-Z]+")) {
                if (matcher.start() == 0 || expression.charAt(matcher.start()-1) == '+') {
                    coef += 1;
                } else if (expression.charAt(matcher.start()-1) == '-') {
                    coef -= 1;
                }
            }
        } while (matcher.find());
        // 遍历完所有项后，根据常数更新系数和常数
        if (!Double.isNaN(coef)) {
            constVal = Double.parseDouble(matcher.group());
        }
        return new double[] {coef, constVal};
    }
}

注意，由于浮点数计算存在精度问题，因此输出结果可能会略有偏差。