java 实现字符串加减乘除的方法

最新推荐文章于 2024-07-24 23:55:03 发布
原创 最新推荐文章于 2024-07-24 23:55:03 发布 · 1.9k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #开发语言
本文介绍了在Java中通过EString类实现字符串的加减乘除功能，以及使用示例，旨在提升字符串处理的灵活性和效率。
Python3.8

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

java 实现字符串加减乘除的方法

一、意义

通过实现字符串的加减乘除方法，可以方便地对字符串进行各种数学运算操作，提高了字符串处理的灵活性和效率。同时，能够实现大数字和精度高的计算。

二、方法

public class EString {
    //大整数相加
    public static String add(String a,String b){
        int base=10;
        int i=a.length()-1,j=b.length()-1;
        //处理进位
        int add=0;
        //通过StringBuilder处理，主要它有反转的这个函数
        StringBuilder ans=new StringBuilder();
        //此处是个大条件，只有一方不满足才会退出
        while(i>=0||j>=0||add!=0){
            //转换为字母通过-‘0’
            int x=i>=0?a.charAt(i)-'0':0;
            int y=j>=0?b.charAt(j)-'0':0;
            int result=x+y+add;
            //添加值到每个字符串的最后一个
            ans.append(result%base);
            //添加进位给予到下一个值
            add=result/base;
            i--;
            j--;
        }
        //字符串的反转
        ans.reverse();
        return ans.toString();
    }
    //大整数相减
    public static String del(String a,String b){
        int i=a.length()-1,j=b.length()-1;
        //处理进位
        int add=0;
        //通过StringBuilder处理，主要它有反转的这个函数
        StringBuilder ans=new StringBuilder();
        //此处是个大条件，只有一方不满足才会退出
        while(i>=0||j>=0||add!=0){
            //转换为字母通过-‘0’
            int x=i>=0?a.charAt(i)-'0':0;
            int y=j>=0?b.charAt(j)-'0':0;
            int result=x-y-add;
            if(result<0) {
                result+=10;
                add = 1;
            }else{
                add=0;
            }
            //添加值到每个字符串的最后一个
            ans.append(result);
            //添加进位给予到下一个值
            i--;
            j--;
            if(i<0&&j<0&&add!=0)
            {
                return "-"+del(b,a);
            }
        }
        //字符串的反转
        ans.reverse();
        return ans.toString();
    }
    //大整数相乘
    public static String mmm(String a,String b){
        int base=10;
        int i=a.length()-1,j=b.length()-1;
        //处理进位
        int add=0;
        //通过StringBuilder处理，主要它有反转的这个函数
        String he;
        String he1="0";
        String he2="";
        String z="";
        int kl = j;
        int kh = i;
        //此处是个大条件，只有一方不满足才会退出
        while(i>=0||j>=0||add!=0){
            //转换为字母通过-‘0’
            int x=i>=0?a.charAt(i)-'0':0;
            int y=j>=0?b.charAt(j)-'0':0;
            int result=x*y+add;
            //添加值到每个字符串的最后一个
            he2=String.valueOf(result%base)+he2;
            //添加进位给予到下一个值
            add=result/base;
            i--;
            if(i<0&&j>=0&&add==0)
            {
                i=kh;
                for (int j1=j;j1<kl;j1++)
                {
                    z=z+"0";
                }
                he=he2;
                he = he+z;
                z="";
                he1=addx(he1,he);
                j--;
                he2="";
            }
        }
        return he1;
    }
    //大整数相除
    public static String ccc(String a,String b){
        if (sw2(b).equals(addx(b, b))) {
            return b;
        }
        int i=a.length()-1,j=b.length()-1;
        //处理进位
        //通过StringBuilder处理，主要它有反转的这个函数
        String he="";
        String he1="";
        String he2="";
        int c=0;
        int q=0;
        //此处是个大条件，只有一方不满足才会退出
        boolean zz = false;
        boolean zz1 = true;
        boolean d3 = false;
        int d = i - j;
        while (true) {
            if (d < 0) {
                he = "0.";
                for (int k = i; k < j; k++) {
                    he1 = a + "0";
                    he = he + "0";
                    zz = true;
                }
                if (zz) {
                    he = he.substring(0, he.length() - 1);
                }
            } else {
                he1 = a.substring(0, j+1);
            }
            while (true) {
                while (true) {
                    String z1 = delx(he1, b);
                    if (z1.indexOf("-") == -1) {
                        break;
                    }
                    int x = d > 0 ? a.charAt(j+1) - '0' : 0;
                    if (d >= 0) {
                        d--;
                        j++;
                        d3=true;
                    }
                    String tt1 = String.valueOf(x);
                    he1 = he1 + x;
                    if(d==-1&&d3)
                    {
                        if(he.length()==0)
                        {
                            he=he+"0";
                        }
                        he=he+".";
                        d--;
                    }
                    if (dd(he) > 20) {
                        return he;
                    }
                    he = he + "0";
                    if(!zz) {
                        zz1 = false;
                    }
                }
                if (!zz1) {
                    he = he.substring(0, he.length() - 1);
                    zz = false;
                }
                while (true) {
                    he2 = he1;
                    he1 = delx(he1, b);
                    q = he1.indexOf("-");
                    if (q == -1) {
                        c++;
                    } else {
                        he = he + String.valueOf(c);
                        he1 = sw(he2);
                        c = 0;
                        if (dd(he) > 20) {
                            return he;
                        }
                        break;
                    }
                }
            }
        }
    }
    //大数相加
    public static String addx(String a,String b){
        if(a.indexOf("-")!=-1)
        {
            String aj =a.replace("-","");
            return sw2(delx(b,aj));
        }
        if(b.indexOf("-")!=-1)
        {
            String bj =b.replace("-","");
            return sw2(delx(a,bj));
        }
        int i=a.length()-1,j=b.length()-1;
        int i1=a.indexOf(".");
        int j1=b.indexOf(".");
        String a1;
        String b1;
        if(i1==-1)
        {
            i1=i;
        }
        if(j1==-1)
        {
            j1=j;
        }
        int l = i-i1 >j-j1 ? i-i1:j-j1;
        if(i-i1==j-j1)
        {
            a1=a.replace(".", "");
            b1=b.replace(".", "");
        }else {
            if (l == i - i1) {
                a1=a.replace(".", "");
                int km = i - i1 - j + j1;
                for (int k = 0; k < km; k++) {
                    b = b + "0";
                }
                b1=b.replace(".", "");
            } else {
                b1=b.replace(".", "");
                int km = -i + i1 +j - j1;
                for (int k = 0; k < km; k++) {
                    a = a + "0";
                }
                a1=a.replace(".", "");
            }
        }
        String c = add(a1,b1);
        StringBuffer c1=new StringBuffer(c);
        if(l!=0) {
            c1.insert(c.length() - l, ".");
        }
        return sw2(c1.toString());
    }
    //大数相减
    public static String delx(String a,String b){
        if(a.indexOf("-")!=-1)
        {
            String aj =a.replace("-","");
            return sw2(delx("0",addx(aj,b)));
        }
        if(b.indexOf("-")!=-1)
        {
            String bj =b.replace("-","");
            return sw2(addx(a,bj));
        }
        int i=a.length()-1,j=b.length()-1;
        int i1=a.indexOf(".");
        int j1=b.indexOf(".");
        String a1;
        String b1;
        if(i1==-1)
        {
            i1=i;
        }
        if(j1==-1)
        {
            j1=j;
        }
        int l = i-i1 >j-j1 ? i-i1:j-j1;
        if(i-i1==j-j1)
        {
            a1=a.replace(".", "");
            b1=b.replace(".", "");
        }else {
            if (l == i - i1) {
                a1=a.replace(".", "");
                int km = i - i1 - j + j1;
                for (int k = 0; k < km; k++) {
                    b = b + "0";
                }
                b1=b.replace(".", "");
            } else {
                b1=b.replace(".", "");
                int km = -i + i1 +j - j1;
                for (int k = 0; k < km; k++) {
                    a = a + "0";
                }
                a1=a.replace(".", "");
            }
        }
        String c = del(a1,b1);
        StringBuffer c1=new StringBuffer(c);
        if(l!=0) {
            c1.insert(c.length() - l, ".");
        }
        return sw2(c1.toString());
    }
    //大数相乘
    public static String mmmx(String a,String b){
        if(a.indexOf("-")!=-1)
        {
            String aj =a.replace("-","");
            return sw2(fu("-"+mmmx(aj,b)));
        }
        if(b.indexOf("-")!=-1)
        {
            String bj =b.replace("-","");
            return sw2(fu("-"+mmmx(a,bj)));
        }
        int base=10;
        int i=a.length()-1,j=b.length()-1;
        int i1=a.indexOf(".");
        int j1=b.indexOf(".");
        String a1;
        String b1;
        if(i1==-1)
        {
            i1=i;
        }
        if(j1==-1)
        {
            j1=j;
        }
        int l = i-i1 >j-j1 ? i-i1:j-j1;
        if(i-i1==j-j1)
        {
            a1=a.replace(".", "");
            b1=b.replace(".", "");
        }else {
            if (l == i - i1) {
                a1=a.replace(".", "");
                int km = i - i1 - j + j1;
                for (int k = 0; k < km; k++) {
                    b = b + "0";
                }
                b1=b.replace(".", "");
            } else {
                b1=b.replace(".", "");
                int km = -i + i1 +j - j1;
                for (int k = 0; k < km; k++) {
                    a = a + "0";
                }
                a1=a.replace(".", "");
            }
        }
        String c = mmm(a1,b1);
        StringBuffer c1=new StringBuffer(c);
        if(l!=0) {
            c1.insert(c.length() - 2*l, ".");
        }
        return sw2(fu(c1.toString()));
    }
    //大数相除
    public static String cccx(String a,String b){
        if(a.indexOf("-")!=-1)
        {
            String aj =a.replace("-","");
            return sw2(fu("-"+cccx(aj,b)));
        }
        if(b.indexOf("-")!=-1)
        {
            String bj =b.replace("-","");
            return sw2(fu("-"+cccx(a,bj)));
        }
        int base=10;
        int i=a.length()-1,j=b.length()-1;
        int i1=a.indexOf(".");
        int j1=b.indexOf(".");
        String a1;
        String b1;
        if(i1==-1)
        {
            i1=i;
        }
        if(j1==-1)
        {
            j1=j;
        }
        int l = i-i1 >j-j1 ? i-i1:j-j1;
        if(i-i1==j-j1)
        {
            a1=a.replace(".", "");
            b1=b.replace(".", "");
        }else {
            if (l == i - i1) {
                a1=a.replace(".", "");
                int km = i - i1 - j + j1;
                for (int k = 0; k < km; k++) {
                    b = b + "0";
                }
                b1=b.replace(".", "");
            } else {
                b1=b.replace(".", "");
                int km = -i + i1 +j - j1;
                for (int k = 0; k < km; k++) {
                    a = a + "0";
                }
                a1=a.replace(".", "");
            }
        }
        String c = ccc(a1,b1);
        return sw2(fu(c));
    }
    //符号显示
    public static String fu(String a){
        int k = findStrCount(a,"-",0);
        if(k%2==0)
        {
            return a.replace("-","");
        }else{
            return "-"+a.replace("-","");
        }
    }
    //小数字点位置
    public static int dd(String a){
        int l=a.length()-1;
        int k = a.indexOf(".");
        if(k==-1) {
            k=l;
        }
        int l1=l-k;
        return l1;
    }
    //包含字符串数
    public static int findStrCount(String oriStr, String findStr, int count) {
        if (oriStr.contains(findStr)) {
            count++;
            count = findStrCount(oriStr.substring(oriStr.indexOf(findStr) + findStr.length()), findStr, count);
        }
        return count;
    }
    //规范1
    public static String sw(String a) {
        if(a.indexOf("-")!=-1){
            return "-"+sw(a.replace("-",""));
        }
        int i = a.length() - 1;
        StringBuilder ans = new StringBuilder();
        int k = 0;
        int ha = 0;
        while (k <= i) {
            //转换为字母通过-‘0’
            char x = k <= i ? a.charAt(k)  : '0';
            if (x != '0' || ha == 1) {
                ans.append(x);
                ha = 1;
            }
            k++;
        }
        String q=ans.toString();
        if(q.length()!=0) {
            char t = q.charAt(0);
            if (t == '.') {
                q = "0" + q;
            }
        }
        if(q.length()==0||q.equals("-0")||q.equals("-"))
        {
            q="0";
        }
        return q;
    }
    //规范2
    public static String sw1(String a) {
        if(a.indexOf("-")!=-1){
            return "-"+sw1(a.replace("-",""));
        }
        if(a.indexOf(".")==-1){
            return a;
        }else {
            int i = a.length() - 1;
            StringBuilder ans = new StringBuilder();
            int ha = 0;
            while (i >= 0) {
                //转换为字母通过-‘0’
                char x = i >= 0 ? a.charAt(i): '0';
                if (x != '0' || ha == 1) {
                    ans.append(x);
                    ha = 1;
                }
                i--;
            }
            String q=ans.reverse().toString();
            if(q.length()!=0) {
                char t = q.charAt(q.length() - 1);
                if (t == '.') {
                    q = q.substring(0, q.length() - 1);
                }
            }
            if(q.length()==0||q.equals("-0")||q.equals("-"))
            {
                q="0";
            }
            return q;
        }
    }
    //规范3
    public static String sw2(String a) {
        String q= sw(sw1(a));
        if(q.length()==0||q.equals("-0")||q.equals("-"))
        {
            q="0";
        }
        return q;
    }
}

三、使用例子

    public static void main(String[] args) {
        System.out.println("数字:");
        System.out.println(addx("12.345678","12.345678"));
        System.out.println(delx("99.123456","12.345678"));
        System.out.println(mmmx("12.345678","12.345678"));
        System.out.println(cccx("99.123456","12.345678"));
    }

输出：

数字:
24.691356
86.777778
152.415765279684
8.029000594378048738999

四、结尾

本方法经过本人多次分析与测试，如有更好的方法或者发现错误的地方欢迎大家评论与指正！

您可能感兴趣的与本文相关的镜像

Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

java 字符串相减(很简单的一个方法)
09-05
本篇文章是对java中关于字符串相减的一个简单的方法进行了介绍，需要的朋友参考下
输入字符串实现加减乘除四则运算（java）
12-06
将近250行的算法 实现了通过字符串进行加减乘除四则运算 纯通过处理字符串和数组实现 希望能帮助大家： 例如：String input "33+26 77+70"; String result ""; try { result AccountString input ; } catch Exception e { TODO: handle exception } System out println result ; 输出 ：2150">将近250行的算法 实现了通过字符串进行加减乘除四则运算 纯通过处理字符串和数组实现 希望能帮助大家： 例如：String input "33+26 77+70"; String result ""; try { result AccountString input ; } catch Exception e { [更多]
java 代码实现 加减乘除表达式的计算
olklj的博客
12-28 1185
【代码】java 代码实现 加减乘除表达式的计算。
Java初始String和运算符
qq_71356343的博客
01-22 1867
Java初始String和运算符
java 字符串相减
weixin_42596246的博客
01-06 2849
在 Java 中, 字符串是不能直接相减的. 你可以把它们转换成数字类型再相减, 但是如果你想要从一个字符串中减去另一个字符串, 你需要使用字符串处理函数来实现. 例如, 你可以使用 String 类的 replace() 方法来实现这个功能: String str1 = "abcdefg"; String str2 = "bcd"; String result = str1.replace(s...
java 实现字符串高次幂的方法
weixin_43329266的博客
12-29 451
java 实现字符串高次幂的方法
java解析并计算字符串算式
日日留心的技术专栏
09-01 1万+
解析并计算，字符串形式的加减乘除算式，我亲测可行的，有一下两种方法： 1.直接通过Java代码，采用递归，手动解析计算： 参考如下连接：https://blog.csdn.net/qq_37969433/article/details/81174046 核心代码也列在下面： /** * 判断表达式是不是只有一个数字 * * @param str 原值 ...
java大整数的加减乘除_关于大整数的加减乘除求余运算 java
weixin_27130513的博客
02-27 731
自己用java 实现了大字符串整数的加减乘除和求余运算，加减法的算法是模拟手工笔算的计算过程，除法就是从最高位不停的减操作，乘法的算法 ：遍历一个数的各个位数以及他所在位置，另一个数根据这个数的位置末位添n个0，然后累加次数为这个位置数的数值原创代码如下：public class Demo6 {public static void main(String[]args){System.out.pri...
java后端实现加减乘除和比例计算
Cike___的博客
02-21 7763
java后端实现加减乘除和比例计算
java实现两个数运算_java 优化版 用接口实现（输入两个数选择实现加减乘除运算）...
weixin_35455673的博客
02-13 1280
//利用java接口实现计算器，实现加减乘除的功能importjava.util.Scanner;classTest {public static voidmain(String[] args) {fun i= newfun();jiafa s1= newjiafa();jianfa s2= newjianfa();chengfa s3= newchengfa();chufa s4= newchu...
加减乘除在java中表示_java加减乘除是什么类
weixin_29798865的博客
02-13 1929
展开全部java中实现加减乘除的类是java.math.BigDecimal类. BigDecimal 类提供以下操作：算术、标度操32313133353236313431303231363533e59b9ee7ad9431333365643536作、舍入、比较、哈希算法和格式转换。加法运算：调用BigDecimal类的add方法即可BigDecimalb1=newBigDecimal("...
关于大整数的加减乘除求余运算 java
weixin_30468137的博客
08-05 115
自己用java 实现了大字符串整数的加减乘除和求余运算， 加减法的算法是模拟手工笔算的计算过程， 除法就是从最高位不停的减操作， 乘法的算法 ：遍历一个数的各个位数以及他所在位置，另一个数根据这个数的位置末位添n个0，然后累加次数为这个位置数的数值 原创代码如下： public class Demo6 { public static void main(String[]ar...
java加减乘除表达式_计算四则运算表达式(Java语言实现)
weixin_39958100的博客
02-13 431
private staticFraction cal(String s) {Stack stack = new Stack();for (int i = 0; i < s.length(); i++) {char c =s.charAt(i);boolean flag = false;int tmp = 0;if (c == ' ')continue;while(is_num(c)) {tm...
JAVA实现简单四则混合运算
故不积跬步，无以至千里。
09-16 5637
java实现加减乘除混合运算， http://www.oschina.net/code/snippet_189899_36597 这个算法很好， 加法 加号前面的加上加号后面的  减法 减号前面的减去减号后面的 乘法 乘号前面的乘上乘号后面的 除法 除法前面的除以除号后面的 递归调用 public static float opt(String s) throws Except
手撸计算机实现
最新发布
sanzailmn的博客
07-24 370
给你一个字符串表达式s，请你实现一个基本计算器来计算并返回它的值。
栈---使用栈完成简单的表达式计算（1-2位数的加减乘除）
BEYONDmonster的博客
09-05 1034
使用Java代码实现使用栈来完成简单的加减乘除表达式的计算。 实现思想： 1.使用数组来模拟栈 2.创建俩个栈，一个数栈：用来存放数据，一个符号栈：用来存放运算符。 3.在数组模拟实现栈的方法的基础上增加新的方法，用于计算运算符优先级的方法，用于返回栈顶的值的方法，用于判断是否是运算符的方法，用于计算结果的方法。 4.给定一个字符串，对字符串的每个字符进行判断 5.先判断是数字还是运算符，然后压入...
java button text_java button action and text change
weixin_39951181的博客
02-16 75
从两个textfield获取两个数据，然后点击不同的button计算加减乘除，结果显示在textarea，但是textField.getText()只能获取String，而且TextArea.setText()只能给String代码如下import javax.swing.*;import java.awt.*;import java.awt.event.ActionEvent;import ja...
BigDecimal使用总结
热门推荐
想着百万年薪努力的小赵
10-18 8万+
对于超过16位的大型数字，需要用到Java在java.math包中提供的API类BigDecimal，而且也不是传统的+-*/，而是调用对应的方法。
java浮点数的精确计算_Java浮点数精确计算
weixin_36313344的博客
02-13 397
在使用java语言编写程序处理一些有关于金额或者精度很高的数据时，通常会使用到一个叫做 BigDecimal的类。BigDecimal是一个封装过的类用于计算一些对结果格式有要求的数值。下面是一个例子:publicstaticvoidmain(String[]args){doublemoney1=2.0;doubleprice1=1.102;System.out.printl...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值