字元串加減java

❶ 【高分懸賞】java實現一個方法計算一個只有加減法運算的表達式的值

這個問題很簡單，只有加減運算，沒有運算優先順序，不需要用到堆棧就可以。下面是代碼：

publicclassApp{

	publicstaticintA(Stringex)throwsException{
		
		intresult=0;
		
		Stringstr="";
		
		for(inti=0;i<ex.length();i++){
			
			charch=ex.charAt(i);
			
			if(ch>='0'&&ch<='9'){
				
				str+=ch;
				
			}elseif(ch=='+'||ch=='-'){
				
				result+=Integer.parseInt(str);
				str=""+ch;
				
			}elseif(ch==''){
				continue;
			}else{
				thrownewException("無效的表達式。");
			}
		}
		
		if(str!=""){
			result+=Integer.parseInt(str);
		}
		
		returnresult;
	}
	
	publicstaticvoidmain(String[]args)throwsException{
		
		intresult=A("1-2+3+4-23");
		
		System.out.println("result="+result);
	}
}

運行結果：

❷ java中怎麼將字元串（帶運算符號加減乘除）轉換成代數算式運算

這需要寫很長一段代碼。
1、判斷表達式中有沒有括弧，如果有括弧，轉第二步。沒有括弧轉第三步。
2、把括弧內的內容提取出來，作為一個新的表達式。轉第三步
3、判斷表達式中有沒有乘號和除號，有轉第四步。沒有轉第六步。
4、把乘除號和乘除號前後的數字提取出來，得到新的表達式，轉第五步。
5、提取數字和符號，判斷表達式是乘號還是除號，然後計算結果。返回。
6、表達式沒有乘除號，有加減號。轉第七步。
7、提取包含加減的表達式中的符號和數據，計算結果，返回。

就是這個道理，這里只是描述了帶括弧和加減乘除的表達式，如果有更多的運算符，則根據運算符優先順序處理。

❸ java 用字元串實現加減法 包括兩位小數 金額格式化 可以為正負 跪求！！！！！！

只寫一個加法的部分的核心代碼，其他類似：
public String calculateAdd( String a,String b)throws Exception{
double a=Double.parseDouble(a);
double b=Double.parseDouble(b);
double result=a+b;
NumberFormat nf2 =
NumberFormat.getInstance(Locale.GERMAN); // 得到德國的格式 ,這里可以設置不
//同國家的格式，無參默認本地
String resultStr=nf2.format(result);
System.out.println(resultStr);
return resultStr;
}

注意：1.傳入的參數是數字組成的字元串，不然會出錯
2.寫代碼時注意引包

❹ 加減乘除運算（Java)

實際上這相當於javascript的eval方法，以下是該方法的java實現：

//Eval.java
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Eval {
public int eval(String exp){
List<String> list = infixExpToPostExp(exp);//轉化成後綴表達式
return doEval(list);//真正求值
}

//遇到操作符壓棧，遇到表達式從後綴表達式中彈出兩個數，計算出結果，壓入堆棧
private int doEval(List<String> list) {
Stack<String> stack = new Stack<String>();
String element;
int n1,n2,result;
try{
for(int i = 0; i < list.size();i++){
element = list.get(i);
if(isOperator(element)){
n1 = Integer.parseInt(stack.pop());
n2 = Integer.parseInt(stack.pop());
result = doOperate(n1,n2,element);
stack.push(new Integer(result).toString());
}else{
stack.push(element);
}
}
return Integer.parseInt(stack.pop());
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
}

private int doOperate(int n1, int n2, String operator) {
if(operator.equals("+"))
return n1 + n2;
else if(operator.equals("-"))
return n1 - n2;
else if(operator.equals("*"))
return n1 * n2;
else
return n1 / n2;
}

private boolean isOperator(String str){
return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
}

private List<String> infixExpToPostExp(String exp){//將中綴表達式轉化成為後綴表達式
List<String> postExp = new ArrayList<String>();//存放轉化的後綴表達式的鏈表
StringBuffer numBuffer = new StringBuffer();//用來保存一個數的
Stack<Character> opStack = new Stack<Character>();//操作符棧
char ch,preChar;
opStack.push('#');
try{
for(int i = 0; i < exp.length();){
ch = exp.charAt(i);
switch(ch){
case '+':
case '-':
case '*':
case '/':
preChar = opStack.peek();
// 如果棧裡面的操作符優先順序比當前的大，則把棧中優先順序大的都添加到後綴表達式列表中
while(priority(preChar) >= priority(ch)){
postExp.add(""+preChar);
opStack.pop();
preChar = opStack.peek();
}
opStack.push(ch);
i++;
break;
case '(':
// 左括弧直接壓棧
opStack.push(ch);
i++;
break;
case ')':
// 右括弧則直接把棧中左括弧前面的彈出，並加入後綴表達式鏈表中
char c = opStack.pop();
while(c != '('){
postExp.add("" + c);
c = opStack.pop();
}
i++;
break;
// #號，代表表達式結束，可以直接把操作符棧中剩餘的操作符全部彈出，並加入後綴表達式鏈表中
case '#':
char c1;
while(!opStack.isEmpty()){
c1 = opStack.pop();
if(c1 != '#')
postExp.add("" + c1);
}
i++;
break;
//過濾空白符
case ' ':
case '\t':
i++;
break;
// 數字則湊成一個整數，加入後綴表達式鏈表中
default:
if(Character.isDigit(ch)){
while(Character.isDigit(ch)){
numBuffer.append(ch);
ch = exp.charAt(++i);
}
postExp.add(numBuffer.toString());
numBuffer = new StringBuffer();
}else{
throw new IllegalExpressionException("illegal operator");
}
}
}
}catch(RuntimeException e){
throw new IllegalExpressionException(e.getMessage());
}
return postExp;
}

private int priority(char op){//定義優先順序
switch(op){
case'+':
case'-':
return 1;
case'*':
case'/':
return 2;
case'(':
case'#':
return 0;
}
throw new IllegalExpressionException("Illegal operator");
}

}

Main.java 主函數所在類
public class Main
{
public static void main(String[] args) {

try {
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String exp=br.readLine();

int result = eval.eval(exp);
System.out.println(result);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

IllegalExpressionException異常類
public class IllegalExpressionException extends RuntimeException{

public IllegalExpressionException(){

}

public IllegalExpressionException(String info){
super(info);
}
}

❺ 怎麼用JAVA做加減混合運算

import java.util.Scanner;

public class HybridOperation {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
System.out.println("輸入一個表達式:");
String s = input.nextLine().trim();
int n = s.length();

int sum = 0;
int p = -1;
char a = '+';

for (int i = 1; i < n; i++) {
char ch = s.charAt(i);
if (ch == '+' || ch == '-') {
if (a == '+') {
sum += Integer.parseInt(s.substring(p + 1, i));
a = ch;
p = i;
} else if (a == '-') {
sum -= Integer.parseInt(s.substring(p + 1, i));
a = ch;
p = i;
}
}
}
if (a == '+') {
sum += Integer.parseInt(s.substring(p + 1));
}
if (a == '-') {
sum -= Integer.parseInt(s.substring(p + 1));
}
System.out.println(s+" = "+sum);
}

}

可以實現任意次數的加減，
如：1+2+3-2

❻ java加減乘除是什麼類

java中實現加減乘除的類是java.math.BigDecimal類. BigDecimal 類提供以下操作：算術、標度操作、舍入、比較、哈希演算法和格式轉換。

加法運算：調用BigDecimal類的add方法即可

BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("2");
BigDecimalresult=b1.add(b2);//加法
System.out.println(result);

減法運算：調用BigDecimal類的subtract方法即可

BigDecimalb1=newBigDecimal(3.2);
BigDecimalb2=newBigDecimal(1.6);
BigDecimalresult=b1.subtract(b2);//減法
System.out.println(result);

乘法運算：調用BigDecimal類的multiply方法即可

BigDecimalb1=newBigDecimal(9);
BigDecimalb2=newBigDecimal(8.2);
BigDecimalresult=b1.multiply(b2);//乘法
System.out.println(result);

除法運算：調用BigDecimal類的divide方法即可。

注意: 除法運算存在除不盡的情況,比如1.0/3=0.333333.. 我們需要指定小數點後面的長度,以及有效的舍入模式(例如四捨五入模式).

BigDecimalb1=newBigDecimal("1");
BigDecimalb2=newBigDecimal("3");
intscale=5;//scale指定小數點後面的位數為5位
doubleresult=b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();//除法
//BigDecimal.ROUND_HALF_UP表示四捨五入
System.out.println(result);

備註：

1：BigDecimal的構造參數有很多，但浮點類型建議轉換成字元串類型, 避免精度的丟失.

doubled1=0.001;//浮點類型
Strings1=Double.toString(d1);//轉成字元串
BigDecimalb1=newBigDecimal(s1);//使用字元串作為構造參數

2：BigDecimal類, 內存佔用比基本類型多,並且為了計算的精度,速度比double慢一點.所以,只有在需要精確計算的情況下,才使用BigDecimal類進行. 普通運算,還是多使用+-*/運算符,位運算符等.

❼ Java 後台做加減法運算，如果變數都是string類型，是不是要先轉換成int類型，才能相加

是呀，string類型實質上是一個數組，相加只是字元串的簡單拼接，運算的話還是要轉成整數

❽ Java的加減乘除問題

//JAVA編程:四則運算(接收用戶輸入的2個操作數，和運算符)，計算之後，輸出結果~~~~
import java.util.Scanner;
public class 四則運算 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("請輸入第一個數字：");
int a = sc.nextInt();
System.out.print("請輸入運算符號：");
String str = sc.next();
char ch = str.charAt(0);
System.out.print("請輸入第二個數字：");
int b = sc.nextInt();
switch(ch)
{
case '+':
System.out.println(a+"+"+ b + "="+(a+b));
break;
case '-':
System.out.println(a+"-"+ b+ "="+(a-b));
break;
case '*':
System.out.println(a+"*"+ b+ "="+(a*b));
break;
case '/':
if(b==0){
System.out.println("被除數為零，運算無意義!");
break;
}
else {
System.out.println(a+"/"+ b+ " = "+(a/b));
break;
}
default:
System.out.println("運算符是無意義字元！");
break;
}
}
}

望採納~~~~~~~~

❾ java的加減乘除運算

使用BigDecimal並且一定要用String來夠造。
實現方法如下：

import java.math.BigDecimal;

/**

* 由於Java的簡單類型不能夠精確的對浮點數進行運算，這個工具類提供精

* 確的浮點數運算，包括加減乘除和四捨五入。

*/

public class Arith{

//默認除法運算精度

private static final int DEF_DIV_SCALE = 10;

//這個類不能實例化

private Arith(){

}

/**

* 提供精確的加法運算。

* @param v1 被加數

* @param v2 加數

* @return 兩個參數的和

*/

public static double add(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.add(b2).doubleValue();

}

/**

* 提供精確的減法運算。

* @param v1 被減數

* @param v2 減數

* @return 兩個參數的差

*/

public static double sub(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.subtract(b2).doubleValue();

}

/**

* 提供精確的乘法運算。

* @param v1 被乘數

* @param v2 乘數

* @return 兩個參數的積

*/

public static double mul(double v1,double v2){

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.multiply(b2).doubleValue();

}

/**

* 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到

* 小數點以後10位，以後的數字四捨五入。

* @param v1 被除數

* @param v2 除數

* @return 兩個參數的商

*/

public static double div(double v1,double v2){

return div(v1,v2,DEF_DIV_SCALE);

}

/**

* 提供（相對）精確的除法運算。當發生除不盡的情況時，由scale參數指

* 定精度，以後的數字四捨五入。

* @param v1 被除數

* @param v2 除數

* @param scale 表示表示需要精確到小數點以後幾位。

* @return 兩個參數的商

*/

public static double div(double v1,double v2,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b1 = new BigDecimal(Double.toString(v1));

BigDecimal b2 = new BigDecimal(Double.toString(v2));

return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

* 提供精確的小數位四捨五入處理。

* @param v 需要四捨五入的數字

* @param scale 小數點後保留幾位

* @return 四捨五入後的結果

*/

public static double round(double v,int scale){

if(scale<0){

throw new IllegalArgumentException(

"The scale must be a positive integer or zero");

}

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();

}

};

❿ java中的String型怎麼實現數學的加減乘除運算

public static void main(String[] args) {
// TODO Auto-generated method stub
BigInteger aa =new BigInteger("100");
BigInteger bb= new BigInteger("25");
BigInteger sub=aa.subtract(bb);//大整數的減
BigInteger add=aa.add(bb);//大整數的加
BigInteger mul=aa.multiply(bb);//大整數的乘
BigInteger div=aa.divide(bb);//大整數的除
System.out.println(sub.toString());
System.out.println(add.toString());
System.out.println(mul.toString());
System.out.println(div.toString());
}