Java原创项目-多项式计算器-带有GUI界面

已于 2022-06-23 19:50:56 修改
阅读量1.1k 收藏 14
点赞数 3
文章标签： java 开发语言 swing
于 2021-12-23 22:28:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A3010367369/article/details/122117622
版权 
package Homework.R2;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;

public class R2 {
    public static void main(String []args){
        R2JFrame R=new R2JFrame();
        R.setTitle("多项式计算器");
    }
}

class R2JFrame extends JFrame {
    R2JPanel P=new R2JPanel();;
    R2JFrame(){
        setDefaultCloseOperation(R2JFrame.EXIT_ON_CLOSE);
        setSize(700,300);
        setLocationRelativeTo(null);
        setResizable(false);
        add(P);
        setVisible(true);
    }
}

class R2JPanel extends JPanel implements ActionListener {
    JButton b1=new JButton("+");
    JButton b2=new JButton("-");
    JButton b3=new JButton("*");
    JButton b4=new JButton("计算");
    JButton b5=new JButton("代数");
    JButton b6=new JButton("求导");
    JButton b7=new JButton("原始");
    JTextField t1=new JTextField();
    JTextField t2=new JTextField();
    JTextField t3=new JTextField();
    JLabel l1=new JLabel("多项式1:");
    JLabel l2=new JLabel("多项式2:");
    JLabel l3=new JLabel("计算结果:");
    JLabel l4=new JLabel("+");
    JLabel l5=new JLabel("=");
    Calculate C=new Calculate();
    R2JPanel(){
        setLayout(null);
        b1.addActionListener(this);
        b2.addActionListener(this);
        b3.addActionListener(this);
        b4.addActionListener(this);
        b5.addActionListener(this);
        b6.addActionListener(this);
        b7.addActionListener(this);
        b1.setBounds(20,20,60,20);
        b2.setBounds(20,80,60,20);
        b3.setBounds(20,140,60,20);
        b4.setBounds(300,200,100,40);
        b5.setBounds(20,200,60,20);
        b6.setBounds(100,200,60,20);
        b7.setBounds(180,200,60,20);
        l1.setBounds(100,20,50,20);
        t1.setBounds(160,20,400,20);
        l2.setBounds(100,80,50,20);
        t2.setBounds(160,80,400,20);
        l3.setBounds(100,140,60,20);
        t3.setBounds(160,140,400,20);
        l4.setBounds(360,50,20,20);
        l5.setBounds(360,110,20,20);
        add(b1);
        add(b2);
        add(b3);
        add(b4);
        add(b5);
        add(b6);
        add(b7);
        add(t1);
        add(t2);
        add(t3);
        add(l1);
        add(l2);
        add(l3);
        add(l4);
        add(l5);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if(e.getSource()==b1){
            C.CA=1;
            l4.setText("+");
            l2.setText("多项式2:");
        }
        else if(e.getSource()==b2){
            C.CA=2;
            l4.setText("-");
            l2.setText("多项式2:");
        }
        else if(e.getSource()==b3){
            C.CA=3;
            l4.setText("*");
            l2.setText("多项式2:");
        }
        else if(e.getSource()==b4){
            String a=t1.getText();
            String b=t2.getText();
            try {
                t3.setText(C.CalculateResult(a, b));
            }
            catch (NumberFormatException s){
                t3.setText("输入格式错误！请重试！");
            }
        }
        else if(e.getSource()==b5){
            C.CA=4;
            l4.setText("&");
            l2.setText("代入数值:");
        }
        else if(e.getSource()==b6){
            C.CA=5;
            l4.setText("'");
            l2.setText("不可用");
        }
        else if(e.getSource()==b7){
            C.CA=6;
            l4.setText("@");
            l2.setText("不可用");
        }
    }
}

class Calculate{
    int CA=1;
    DX A1=new DX();
    DX A2=new DX();
    DX RE=new DX();

    Calculate(){
    }

    String CalculateResult(String a,String b){
        if(CA==1){
            A1.create(a);
            A2.create(b);
            RE.add(A1,A2);
        }
        if(CA==2){
            A1.create(a);
            A2.create(b);
            RE.subtract(A1,A2);
        }
        if(CA==3){
            A1.create(a);
            A2.create(b);
            RE.multiply(A1,A2);
        }
        if(CA==4){
            A1.create(a);
            double n=Double.parseDouble(b);
            return A1.Algebra(n)+"";
        }
        if(CA==5){
            A1.create(a);
            RE.derivatives(A1);
        }
        if(CA==6){
            A1.create(a);
            return A1.ToString();
        }
        return RE.toString();
    }
}

class DX{
    BigDecimal [][]A;
    void create(String s){
        BigDecimal [][]R=new BigDecimal[2][500];
        String []M=new String[500];
        int K=0;
        int i=0;
        int a=0;
        int b;
        while(true){
            int e1,e2;

            if(K==0) {
                e1 = s.indexOf("-", 1);
                while(e1-1>=1&&s.charAt(e1-1)=='^'){
                    e1=s.indexOf("-",e1+1);
                }
                e2 = s.indexOf("+", 1);
                K=1;
            }
            else{
                e1=s.indexOf("-",a+1);
                while(e1-1>=1&&s.charAt(e1-1)=='^'){
                    e1=s.indexOf("-",e1+1);
                }
                e2=s.indexOf("+",a+1);
            }
            if(e1>-1&&e2>-1){b=getMin(e1,e2);}
            else if(e1<0&&e2<0){M[i]=s.substring(a);i++;break;}
            else if(e1>=0){b=e1;}
            else {b=e2;}
            M[i]=s.substring(a,b);
            i++;
            a=b;
        }
        for(int d=0;d<i;d++) {
            int t = M[d].indexOf("x");
            if (t < 0) {
                R[0][d] = new BigDecimal(M[d]);
                R[1][d] = new BigDecimal("0");
            } else {
                t = M[d].indexOf("x^");
                if (t < 0) {
                    if (M[d].length() == 1) {
                        R[0][d] = new BigDecimal("1");
                        R[1][d] = new BigDecimal("1");
                    } else if (M[d].length() == 2 && M[d].contains("-")) {
                        R[0][d] = new BigDecimal("-1");
                        R[1][d] = new BigDecimal("1");
                    }
                    else if (M[d].length() == 2 && M[d].contains("+")) {
                        R[0][d] = new BigDecimal("1");
                        R[1][d] = new BigDecimal("1");
                    } else {
                        R[0][d] = new BigDecimal(M[d].substring(0, M[d].indexOf("x")));
                        R[1][d] =new BigDecimal("1");
                    }
                } else {
                    t = M[d].indexOf("x");
                    if (t == 0) {
                        R[0][d] = new BigDecimal("1");
                    } else if (t == 1 && M[d].charAt(0) == '-') {
                        R[0][d] = new BigDecimal("-1");
                    } else if (t == 1 && M[d].charAt(0) == '+') {
                        R[0][d] = new BigDecimal("1");
                    } else {
                        R[0][d] = new BigDecimal(M[d].substring(0, t));
                    }
                    R[1][d] = new BigDecimal(M[d].substring(t + 2));
                }
            }
        }
        for(int x=0;x<i-1;x++){
            for(int y=x+1;y<i;y++){
                if(R[1][x].compareTo(R[1][y])<0){
                    BigDecimal x1=R[0][x],x2=R[1][x];
                    R[0][x]=R[0][y];R[1][x]=R[1][y];
                    R[0][y]=x1;R[1][y]=x2;
                }
            }
        }
        A=new BigDecimal[2][i];
        for(int u=0;u<i;u++){
            A[0][u]=R[0][u];
            A[1][u]=R[1][u];
        }
        A=Simplify(A);
    }

    int getMin(int a,int b){
        return Math.min(a, b);
    }

    BigDecimal[][] Simplify(BigDecimal [][]F){
        for(int i=0;i<F[0].length-1;i++){
            for(int y=i+1;y<F[0].length;y++){
                if(F[0][i].compareTo(new BigDecimal("0"))!=0&&F[0][y].compareTo(new BigDecimal("0"))!=0) {
                    if (F[1][i].compareTo(F[1][y])==0) {
                        F[0][i] = F[0][i] .add(F[0][y]);
                        F[0][y] = new BigDecimal("0");
                    }
                }
            }
        }
        int s =0;
        for(int i=0;i<F[0].length;i++){
            if(F[0][i].compareTo(new BigDecimal("0"))!=0){s++;}
        }
        BigDecimal [][] Y=new BigDecimal[2][s];
        s=0;
        for(int i=0;i<F[0].length;i++){
            if(F[0][i].compareTo(new BigDecimal("0"))!=0){
                Y[0][s]=F[0][i];
                Y[1][s]=F[1][i];
                s++;}
        }
        for(int x=0;x<s-1;x++){
            for(int y=x+1;y<s;y++){
                if(Y[1][x].compareTo(Y[1][y])<0){
                    BigDecimal x1=Y[0][x],x2=Y[1][x];
                    Y[0][x]=Y[0][y];Y[1][x]=Y[1][y];
                    Y[0][y]=x1;Y[1][y]=x2;
                }
            }
        }
        return Y;
    }
    void add(DX A,DX B){
        BigDecimal [][]E=new BigDecimal[2][A.A[0].length+B.A[0].length];
        System.arraycopy(A.A[0], 0, E[0], 0, A.A[0].length);
        System.arraycopy(A.A[1], 0, E[1], 0, A.A[0].length);
        System.arraycopy(B.A[0], 0, E[0], A.A[0].length, B.A[0].length);
        System.arraycopy(B.A[1], 0, E[1], A.A[0].length, B.A[0].length);
        this.A=E;
        this.A=Simplify(this.A);
    }
    void subtract(DX A,DX B){
        for(int i=0;i<B.A[0].length;i++){
            B.A[0][i]=B.A[0][i].multiply(new BigDecimal("-1"));
        }
        BigDecimal [][]E=new BigDecimal[2][A.A[0].length+B.A[0].length];
        System.arraycopy(A.A[0], 0, E[0], 0, A.A[0].length);
        System.arraycopy(A.A[1], 0, E[1], 0, A.A[0].length);
        System.arraycopy(B.A[0], 0, E[0], A.A[0].length, B.A[0].length);
        System.arraycopy(B.A[1], 0, E[1], A.A[0].length, B.A[0].length);
        this.A=E;
        this.A=Simplify(this.A);
    }
    void multiply(DX A,DX B){
        BigDecimal [][]E=new BigDecimal[2][A.A[0].length*B.A[0].length];
        int s=0;
        for(int x=0;x<A.A[0].length;x++){
            for(int y=0;y<B.A[0].length;y++){
                E[0][s]=A.A[0][x].multiply(B.A[0][y]);
                E[1][s]=A.A[1][x].add(B.A[1][y]);
                s++;
            }
        }
        this.A=E;
        this.A=Simplify(this.A);
    }
    void derivatives(DX A){
        BigDecimal [][]E=new BigDecimal[2][A.A[0].length];
        for(int i=0;i<A.A[0].length;i++){
            if(A.A[1][i].compareTo(new BigDecimal("0"))==0){E[0][i]=new BigDecimal("0");}
            else{
                E[0][i]=A.A[0][i].multiply(A.A[1][i]);
                E[1][i]=A.A[1][i].subtract(new BigDecimal("1"));
            }
        }
        this.A=E;
        this.A=Simplify(this.A);
    }
    double Algebra(double n){
        double s=0;
        for(int i=0;i<A[0].length;i++){
            s=s+Double.parseDouble(A[0][i]+"")*Math.pow(n,Double.parseDouble(A[1][i]+""));
        }
        return s;
    }
    public String toString(){
        String S="";
        for(int i=0;i<A[0].length;i++){
            if(A[0][i].compareTo(new BigDecimal("0"))!=0){
                if(A[1][i].compareTo(new BigDecimal("0"))==0){
                    if(A[0][i].compareTo(new BigDecimal("0"))<0){S=S+A[0][i];}
                else{S=S+"+"+A[0][i];}}
                else if(A[0][i].compareTo(new BigDecimal("-1"))==0){S=S+"-";}
                else if(A[0][i].compareTo(new BigDecimal("1"))==0){S=S+"+";}
                else if(A[0][i].compareTo(new BigDecimal("0"))>0){S=S+"+"+A[0][i];}
                else{S=S+A[0][i];}
            }
            if(A[1][i].compareTo(new BigDecimal("0"))!=0){
                S=S+"x";
                if(A[1][i].compareTo(new BigDecimal("1"))!=0){
                    S=S+"^"+A[1][i];
                }
            }
        }
        if(S.equals("")){S="0";}
        if(S.charAt(0)=='+'){S=S.substring(1);}
        return S;
    }
    public String ToString(){
        String S=A[0].length+"";
        for(int i=0;i<A[0].length;i++){
            S=S+","+A[0][i]+","+A[1][i];
        }
        return S;
    }

}

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*1

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*2

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*3

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*4

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*5

希望这个项目能够帮助大家学习Java,学习Java Swing,做Java项目有所帮助,本文项目包括源文件已被打包为jar文件和java及class文件*6(重复勿介意)

这个程序能够计算两个多项式的和,积,差,并且具有强大的异常处理机制,能够计算 任意大小系数,小数,指数,

由于网站采用自签名SSL证书开启https,所以可能提示证书不可信,请放心使用

https://study.gengronglin.top/Source/R2.zip

已经发布到本人服务器上,供大家免费下载,学习

这是本人原创项目作品,供大家学习观摩使用,请尊重原创,转载务必声明出处

A3010367369
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
PolynomialCalculator:多项式计算器
04-16
PolynomialCalculator 作者：HuangDell 说明：这是C++老师布置的大作业——多项式计算器，其基本功能如下： 1.读取多项式。按照(名称)=(系数，指数)的格式。如果没有输入名称，软件会自动为你添加None的名称，你可以直接使用它。注意：并不要求输入的多项式按照降序排序。ps(并不支持小数输入！) 2.多项式的加、减、乘、求导、求值、判断相等运算。每次执行完运算后会将答案存储至ans这个特殊的多项式中，所以请避免使用ans来命名其它多项式。 3.多项式的存储。软件会将你每次输入的多项式进行存储，你可以在程序运行期间查看它们，但是请注意关闭程序后这些多项式将会被自动清除！其中ans、None多项式始终都只有一个，这取决你的最近一次计算或者添加多项式。 编译环境： gcc version 8.1.0--support c++ 11 获取源码： 请访问我的github来
基于Java带界面的多项式计算器
11-18
采用WindowsBuilder构建界面，用HashMap储存多项式，实现多项式的加减运算，求导。通过最简行列式实现对求线性方程组的求解，并输出通解。有较好的容错处理，输入时指数用^表示，下标用_表示，eg：3X^2 2X_1
C++一元多项式计算器的设计与实现
程序设计
11-12 925
七、一元多项式计算器的设计与实现1.基于动态数组或者链表实现- -元多项式的计算,可以使用STL的vector或者list。2.在系统中需要提供必要的成员函数和运算符实现对象的构造、复制、赋值和输入/输出等操作。3.重载运算符实现多项式的算术运算:加、减、乘、除(带余数的除法)、取余。4.重载圆括号运算符: 给定一个自变量值，计算多项式在该点的函数值。5.实现多项式的微分运算和积分运算:若给定一个整数n， 则表示微分运算或积分运算的阶数;若还给定一个区间，则计算在该区间，上的定积分。
java 简易计算器
热门推荐
m0_56078449的博客
07-15 2万+
java 简易计算器
多项式加减法计算器（C语言）
m0_53281665的博客
10-24 371
多项式加减法计算器（C语言） 输入：每组数据有3行构成，第1行为3个正整数n，m，t， n表示第一个多项式的项数，m表示第二个多项式的项数，t表示运算类型，0为加法，1为减法，每组数据的第2行包含2n个整数，每两个整数分别表示第一个多项式每一项的系数和指数；第3行包含2m个整数，每两个整数分别表示第二个多项式每一项的系数和指数。 输出：在一行上以多项式形式输出结果，指数按从低到高的顺序 输入样例： 6 3 0 1 0 1 1 -3 2 1 3 1 4 1 5 -1 3 -2 41 5 输出.
一元多项式计算器（C语言实现）
qq_62225979的博客
01-17 2484
数据结构线性表的链式存储的一个实验 用C语言实现了一元多项式的加、减、乘、求导、求值运算
多项式计算器-简易版本-java
04-14
1.可进行多位整数、小数运算。 2.可进行简单的多项式运算，但是没有小括号 3.输入“=”，之后还可以接着运算，但之前的运算结果会丢失
C语言-一元稀疏多项式计算器
03-27
一元稀疏多项式计算器，实现一元稀疏多项式的加减乘除
基于Java实现的一元稀疏多项式计算器.zip
07-04
通过按钮组选择输出结果：多项式计算结果、在某点的值、多项式的导数(扩展功能)； 多项式的计算功能；多项式的求值功能；多项式的求导功能。 详细介绍参考：https://blog.csdn.net/newlw/article/details/124926217
c一元稀疏多项式计算器-课程设计实验报告.pdf
10-30
c一元稀疏多项式计算器-课程设计实验报告.pdfc一元稀疏多项式计算器-课程设计实验报告.pdf
【Java GUI】用java实现简单计算器的制作 项目（一）
m0_72091619的博客
05-01 5397
3，设置窗口的各种按钮（需添加数字1~9，小数点，运算符号，括号，等号，清除删除键等等），并往相应按钮中添加相应字符，便于向用户展示相字符的作用（此处不含按钮监听事件），同时也可以优化按钮设置如数字0~9用同一个颜色，运算符用一个颜色，等号用为一颜色用于区分，关于按钮布局可以模仿微软计算器中的布局。3：由于存储字符串时使用的是栈，所以可以同时实现括号匹配问题的判断，某些错误表达式输入的限制如两个运算符不能相邻输入 ：（1+/2）该表达式就是错误的，此时只需要在输入前查看栈顶元素并与输入的元素进行判断即可。
基于Java实现计算器功能（控制台版+Java Swing图形用户界面（GUI）版+附带论文）
weixin_51114682的博客
05-22 772
【代码】基于Java实现计算器功能（控制台版+Java Swing图形用户界面（GUI）版+附带论文）
Java 实现计算器
万伏小太阳
02-28 4439
要求：（1）在程序中要体现面向对象编程语言的三大特征：封装、继承和多态。（2）该程序要易于扩展和复用。以后可以方便地增加新的运算；程序的业务逻辑与界面部分要实现分离，便于业务逻辑的复用。（3）使用UML类图描述程序的结构。指出你所设计的程序符合哪些设计原则。
java计算器(带图形界面)
qq_41359808的博客
05-31 809
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class JCalculator extends JFrame implements ActionListener { private final String[] str = { "7", "8", "9", "/", "4",...
一元多项式运算器-代码实现(c语言)
scfvlog的博客
01-09 1241
要求学生运用数据结构基本原理、计算机高级程序设计语言和相关工具，分析并求解符号计算领域中的一元多项式运算问题，实现一元多项式的加法、减法、乘法、求值、求导、求积分等运算。代码实现：里面有文件操作，伪分布随机数生成，时间函数使用，结构体使用等等，全部代码由本人手写，希望各位不要抄袭，仅供参考学习，不要用于非法用途。代码运行的问题可以私聊我账号，切记不要抄袭！
Java简单计算器界面及功能的实现
emandora的博客
01-09 9645
实验要求 编写计算器界面并实现其功能。 实验步骤 1.界面基本样式绘制 代码实现 import java.awt.*; import javax.swing.*; public class f_frame extends JFrame{ public f_frame() { //创建界面,设置其大小为固定值，宽900，高650，使整个界面都可以正常显示 JFrame f=new JFrame("计算器"); f.setSize(900, 650); Conta...
一元多项式计算器（程序对于多项式运算非常通用、细节很多详见描述与代码）
flow
12-17 1567
程序支持除题目要求外的所有“任意多个”一元多项式加减运算输入: 测试用例: -(2x^3+5x^4)+2x^5+(2x+5x^8-3.1x^11)+4x^6+2x^2+(7-5x^8+11x^9)+(x+x^2-x^3)+10= -2x^5+(2x+5x^8-3.1x^11)+4x^6+2x^9+(7-5x^8+11x^9)+(x+x^2+x^3)+2x^7= (2x+5x^8-3.1x^11)+(7-5x^8+11x^9)= (6x^-3-x+4.4x^2-1.2x^9)-(-7x^...
【数据结构-C语言】一元多项式计算器
Brave_Runer的博客
04-29 4334
#include <stdio.h> #include <stdlib.h> typedef struct PolyNode *Polynomial;//存储结构为：带头节点的单链表 struct PolyNode { int coef;//多项式系数 int expon;//多项式指数 Polynomial next;//指向下一个节点 }; t...
一元稀疏多项式简单计算器（C语言）含注释
m0_62925086的博客
02-22 5792
一元稀疏多项式简单计算器（C语言）含注释 问题描述 设计一个一元稀疏多项式简单计算器 基本要求 一元稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b。
用Java编写一元稀疏多项式计算器
最新发布
08-17
1. 输入多项式：可以通过控制台或者GUI界面获取用户输入的系数和指数，并将其添加到多项式中。 2. 输出多项式：遍历多项式中的每个节点，并输出其系数和指数。 3. 一元稀疏多项式的加法：遍历两个多项式的节点，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A3010367369

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值