String Java dikonversi menjadi ekspresi aritmatika untuk menghitung dan mengeluarkan hasilnya. Alat ini dapat secara langsung menghitung ekspresi aritmatika dalam bentuk string, dan sangat mudah digunakan.
Alat ini berisi dua kalkulator kelas dan arithhelper
Kode kalkulator adalah sebagai berikut:
import java.util.Collections;import java.util.Stack;/** * Arithmetic expression evaluation* Directly call Calculator's class method conversion() * Passing in an arithmetic expression will return a floating-point value result* If the calculation process is incorrect, a NaN will be returned */public class Calculator {private Stack<String> postfixStack = new Stack<String>();// Suffix stack private Stack<Character> opStack = new Stack<Character>();// Operator stack private int[] operatorPriority = new int[] { 0, 3, 2, 1, -1, 1, 0, 2 };// Operator priority using operator ASCII code-40 for indexing public static double conversion(String expression) {double result = 0;Calculator cal = new Calculator();try {expression = transform(expression);result = cal.calculate (ekspresi);} catch (pengecualian e) {// e.printstacktrace (); // kesalahan operasi mengembalikan nanreturn 0.0/ 0.0;} // mengembalikan string baru (). Nilai (hasil); hasil kembali;}/ *** Simbol dari angka negatif dalam ekspresi** @param ekspresi* untuk contoh -2 ~ 2+~ 1 *(~ 3e ~ 2)-(~ 1) *@return */private static string transformasi (ekspresi string) {char [] arr = ekspresi.tochararray (); untuk (int i = 0; i <arr.length; i ++) {if (i] == '-') {if (i == 0) {if (i] == '-') {if (i == 0) {arr [i] == '-') {if (i == 0) {arr [i] == '- (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == 'e' || c == 'e') {arr [i] = '~';}}}} if (arr [0] == '~' ~ '; String(arr);} else{return new String(arr);}}/** * Calculate according to the given expression* * @param expression * The expression to be calculated for example: 5+12*(3+5)/7 * @return */public double calculate(String expression) {Stack<String> resultStack = new Stack<String>();prepare(expression);Collections.reverse(postfixStack);// Invert the Suffix Stack String FirstValue, SecondValue, CurrentValue; // Nilai pertama, SecondValue, CurrentValue; // nilai pertama, nilai kedua dan operator aritmatika yang berpartisipasi dalam perhitungan sementara (! PostfixStack.isempty () {currentValue = PostfixStack.pop (); if (! Operator, menyimpannya di tumpukan operan CurrentValue = CurrentValue.replace ("~", "-"); hasilnya. Tanda negatif FirstValue = firstValue.replace ("~", "-"); SecondValue = SecondValue.Replace ("~", "-"); String Tempresult = Hitung (FirstValue, SecondValue, CurrentValue.Charat (0)); hasil Hasil. double.valueof (resultStack.pop ());}/** * Tahap persiapan data mengubah ekspresi menjadi tumpukan sufiks * * @param ekspresi */void pribadi persiapan (ekspresi string) {opstack.push (','); // operator menempatkan koma di elemen bawah tumpukan, dan simbol ini memiliki dataran rendah. 0; // Posisi karakter saat ini adalah int count = 0; // Panjang karakter dari operator aritmatika terakhir ke operator aritmatika ini adalah CHAR Currentop yang nyaman atau numerik, peekop; // operator saat ini dan Operator Top-stack untuk (int i = 0; i <arr.length; i ++) {Current-stack = ARR [i]; (count > 0) {postfixStack.push(new String(arr, currentIndex, count));// Take the number between two operators}peekOp = opStack.peek();if (currentOp == ')') {// When encountering an unbranch, remove the element in the operator stack to the suffix stack until the opening bracket is encountered (opStack.peek() != '(') {PostFixStack.push (string.valueof (opstack.pop ()));} opstack.pop ();} else {while (currentop! = '(' && peekop! = ',' && bandingkan (currentop, peekop)) {postfixstack.push (string.valueof (Opstack) {PostFixStack.push.push.valueof (Opstack (Opstack) (Opstack.) = Opstack.Push.push.valueof (Opstack (Opstack () = Opstack.Push.push.valueof (Opstack (Opstack () = Opstack.Push.push. opstack.peek ();} opstack.push (currentop);} count = 0; currentIndex = i+1;} else {count ++;}} if (count> 1 || (count == 1 &&! isOperator (arr [currentIndex])) {// jika karakter terakhir bukan pita, CurrentIndex, Count));} while (opstack.peek ()! = ',') {postfixstack.push (string.Valueof (opstack.pop ())); // Tambahkan elemen yang tersisa dalam tumpukan operator @charet *}}/** * Tentukan apakah itu simbol armetika @pondok @** ** {return c == '+' || c == '-' || c == ' *' || c == '/' || Cur, return true, prioritas mengintip default adalah hasil boolean yang lebih rendah = false; if (operatpriority [(peek) - 40]> = operatorpriority [(cur) - 40]) {result = true;} hasil pengembalian;}/** Calculated sesuai dengan string @pretv @param * @paramal * @paramal * @paramal * @paramal * @paramal * FirstValue, String SecondValue, char currentop) {string result = ""; switch (currentop) {case '+': result = string.ValueOf (arithhelper.add (firstValue, secondValue)); break; case '-': hasil = string.valueOf (arithhelper.sub (firstValue (firstvalue = secome; String.ValueOf (Arithhelper.mul (FirstValue, SecondValue)); break; case '/': result = string.ValueOf (arithhelper.div (firstValue, SecondValue)); break;} hasil pengembalian;}}Kode Arithhelper adalah sebagai berikut:
Kelas Publik ArithHelper {// Operasi Divisi Default Akurasi Pribadi Static Final Int DEF_DIV_SCALE = 16; // Kelas ini tidak dapat dipakai ArithHelper private () {}/*** menyediakan operasi penambahan yang akurat. * * @param v1 ditambahkan * @param v2 add * @return Jumlah dari dua parameter */public static double add (double v1, double v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (double.tostring (v1)); java.math.math java.math.bigdecimal (double.tostring (v2)); return b1.add (b2) .doublevalue ();} public static add (string v1, string v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (vovaMal (vovaCim.b1 (vovaCim.bigy (java. java.math.bigdecimal (v2); return b1.add (b2) .doublevalue ();}/*** menyediakan operasi pengurangan yang akurat. ** @param V1 dikurangi* @param V2 Kurangi* @Return Perbedaan antara dua parameter*/public static ganda sub (v1 ganda, v2 ganda) {java.math.bigdecimal b1 = java.math.bigdecimal (double.tostring (v1)); java.math.math.bigdecimal (double.tostring (v1)); java.math java.math.bigdecimal (double.toString (v2)); return b1.subtract (b2) .doublevalue ();} public static sub sub (string v1, string v2) {java.math.bigdecimal b1 = new java.math.bigdecimal (java.biMal (java. java.math.bigdecimal (v2); return b1.subtract (b2) .doublevalue ();}/*** menyediakan operasi multiplikasi yang akurat. * * @param V1 * Multiplier * @param V2 * Multiplier * @Return Produk dari dua parameter */public static double Mul (Double V1, Double V2) {java.math.bigdecimal b1 = java.math.bigdecimal (double.tostring (v1); java.math.bigdecimal (double.tostring (v2)); return b1.multiply (b2) .doublevalue ();} public static mul double (string v1, string v2) {java.math.bigdecimal b1 = new java.math.bigdecimal b1 = new java.math.bigdecimal (java. baru java.math.bigdecimal (v2); return b1.multiply (b2) .doublevalue ();}/*** memberikan (relatif) operasi pembagian yang akurat. Ketika tidak ada pembagian, itu akurat hingga 10 digit setelah titik desimal, dan angka -angka berikutnya dibulatkan. * * @param V1 * Divider * @param V2 * Divider * @Return kutipan dari dua parameter */public static div ganda (v1 ganda, v2 double) {return div (v1, v2, def_div_scale);} public static div double (string v1, string v2) {java.bigdal java.math.bigdecimal (v1); java.math.bigdecimal b2 = baru java.math.bigdecimal (v2); return b1.divide (b2, def_div_scale, java.math.bigdecimal.round_up_half) .doat. Operasi Divisi. Ketika tidak ada akhir untuk menyelesaikan pemisahan, akurasi ditentukan oleh parameter skala, dan angka -angka selanjutnya dibulatkan. ** @param V1 Divider* @param V2 Divider* @param Skala berarti bahwa itu harus akurat untuk beberapa digit setelah titik desimal. * @return quotient dari dua parameter*/public static double div (v1 ganda, v2 ganda, skala int) {if (skala <0) {lempar baru ilegalargumentException ("Skala harus integer positif atau nol");} java.math.bigdecimal b1 = baru = nol ");} java.math.bigdecimal b1 = new baru");} java.math.bigdecimal b1 = new baru "); java.math.bigdecimal (double.tostring (v1)); java.math.bigdecimal b2 = baru java.math.bigdecimal (double.tostring (v2)); return b1.divide (B2, skala, skala, java.math.bigdecimal.round_half_up) .doublevalue ();}/*** menyediakan pembulatan desimal yang akurat. ** @param V menghitung yang perlu dibulatkan* @param skala berapa banyak digit yang dipertahankan setelah titik desimal* @return hasilnya setelah pembulatan*/public static round (ganda V, skala int) {if (skala <0) {lempar new ilegalargumentException ("skala harus integer positif atau zero");} java. java.math.bigdecimal (double.toString (v)); java.math.bigdecimal one = java.math.math.bigdecimal ("1") baru (pondas (skala satu, java. {if (skala <0) {lempar IllegalArgumentException baru ("Skala harus berupa bilangan bulat positif atau nol");} java.math.bigdecimal b = java.math.math.bigdecimal (v) (java.Math.Math.bigdecimal One. java.math.bigdecimal.round_half_up) .doublevalue ();}}Saat menggunakannya, panggil metode konversi () dari kelas kalkulator dan lulus dalam parameter ekspresi aritmatika untuk mengembalikan nilai tipe ganda.
Contoh Penggunaan:
Public Class MathTest {public static void main (string [] args) {string ekspresi = "(0*1--3) -5/-4- (3*(-2.13))"; hasil ganda = calculator.conversion (ekspresi); System.out.println (ekspresi + "=" + hasil); System.out.println ();Output Konsol:
(0*1--3) -5/-4- (3*(-2.13)) = 10.64
Tes screenshot:
Meringkaskan
Di atas adalah semua penjelasan terperinci tentang kode ekspresi matematika komputasi Java, saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!