java算數
1. java算數運算。
publicclassTest{
//第一題
publicstaticvoidmain(String[]args){
inta=5;
intb=7;
System.out.println(a=++a+a+++b++);
}
}
//第二題
publicclassTest{
publicstaticvoidmain(String[]args){
inta=5;
intb=7;
inttemp;
temp=b;
b=a;
a=temp;
System.out.println("a="+a);
System.out.println("b="+b);
}
}//第三題看不清
2. Java的字元能參加算術運算嗎 Java的字元能參加算術運算嗎 求大神回答！
java的字元可以進行算術運算，
char類型，在和字元串連接時，是字元形式；在和數字運算時是數字形式，按hashcode碼對應。
http://pan..com/share/init?shareid=1002691859&uk=2436338859
這里有付強老師講解char的一個題目，希望對你有幫助，提取密碼是6ri4
3. JAVA怎麼進行基礎的算數運算
就是按照它的運算規則，你是個題目不太清楚，他一般在進行算術的運算的時候，都是通過補碼來進行運算。
4. java 算數運算 問題
*是特殊符號，把*號換掉，用別的字元代替即可
classCaculate
{
publicstaticvoidmain(String[]args)
{
charf=args[1].charAt(0);
System.out.println(args[0]+"--"+args[1]+"--"+args[2]);
inta=Integer.parseInt(args[0]);
intb=Integer.parseInt(args[2]);
doublec;
switch(f)
{
case'+':
System.out.println(a+b);
break;
case'-':
System.out.println(a-b);
break;
case'c':
c=a*b;
System.out.println(c);
break;
case'/':
c=3/4;
System.out.println(c);
break;
case'%':
System.out.println(a%b);
break;
}
}
}
5. Java輸出整數的算數平方根
import java.text.*;//這里我就不對下面那個輸入做判斷了，要想寫的健壯一點要加入判斷輸入數據的函數編譯之後在命令行下輸入java A 你要輸入的數值用空格隔開，因為我沒對輸入類型做判斷，謹慎！或者在eclipse的命令行也行
public class A {
public static void main(String[] args){
double[] a =new double[args.length];
DecimalFormat dcmFmt = new DecimalFormat("0.0000");for(int i=0;i<args.length;i++)
{
a[i]=Math.sqrt(Double.parseDouble(args[i]));
System.out.println( dcmFmt.format(a[i]));
}}
}
6. java 算數代碼
<p>selectuser.id,user.name,buy.id,buy..id=buy.useridorderbybuy.timeascgroupbybuy.userid;</p><p>演算法這題題目有點問題，每種獎品的數量都知道了，難道所有獎品的總數量會不知道嗎？所以這個count我只能理解為，需要抽出的獎品的數量，即抽獎幾次。</p><p>割一下-----------------------------------------------------------------</p><p>又仔細看了一下題目，發現最終返回的是一個String，也就是只抽一次獎，具體要根據每種獎品的數量不同來計算概率進行抽獎，count的確是所有獎品的數量，但是我從map把每種獎品的總數累加，不就是所有獎品數量了嘛。。。傳個count確實是多此一舉了
publicstaticStringdraw(Map<String,Integer>map,intcount){
//產生1-count之間的隨機數
Integerrandom=newRandom().nextInt(count)+1;
//map的key，即獎品名稱
Set<String>keys=map.keySet();
//map的value值,即每種獎品的數量
Collection<Integer>values=map.values();
//題目明確說了有3種獎品，獲取前兩種獎品的數量
Integercount1=(int)values.toArray()[0];
Integercount2=(int)values.toArray()[1];
Stringname=null;//獎品名稱
if(random<=count1){//表示抽中第一種獎品
name=(String)keys.toArray()[0];
}elseif(random>count1+count2){//表示抽中第三種獎品
name=(String)keys.toArray()[2];
}else{//表示抽中第二中獎品
name=(String)keys.toArray()[1];
}
returnname;
}
7. 用JAVA 產生兩個隨機數完成算數運算
import java.util.Random;
import javax.swing.JOptionPane;
public class Compute {
public int getRandomValue()
{
//0~100之間的隨機數,如果沒有范圍把rd.nextInt(100)中的100去掉，但是計算機的整數很大，一個隨機數可能是幾百億
Random rd = new Random();
return rd.nextInt(100);
}
public int getLeftOperand(){
return getRandomValue();
}
public int getRightOperand(){
return getRandomValue();
}
public static void main(String[] args) {
Compute c = new Compute();
int x = c.getLeftOperand();
int y = c.getRightOperand();
int z = x+y;
System.out.println("x="+x+", y="+y+",z="+z);
String userInputAnswer = JOptionPane.showInputDialog("Please calculate the formula:"+x+"+"+y+"=?\nPlease input answer:");
int t = 0;
try{
t=Integer.parseInt(userInputAnswer);
}catch(NumberFormatException e){
JOptionPane.showMessageDialog(null,"The result must be a number!","ERROR",JOptionPane.YES_OPTION);
return;
}
if(z==t)
JOptionPane.showMessageDialog(null, "Congratulations! you are correct, the answer is "+z);
else
JOptionPane.showMessageDialog(null, "Sorry! your answer is not correct, the answer is "+z,"Result",JOptionPane.YES_OPTION);
}
}
8. java怎麼計算一個整數長度（不含負數符號）
實現方法如下：
1 把這個數取絕對值
2 然後轉成字元串，然後用length函數獲取長度就行了。
9. java實現算術表達式求值
import java.util.Collections;
import java.util.Stack;
public class Calculator {
private Stack<String> postfixStack = new Stack<String>();//後綴式棧
private Stack<Character> opStack = new Stack<Character>();//運算符棧
private int [] operatPriority = new int[] {0,3,2,1,-1,1,0,2};//運用運算符ASCII碼-40做索引的運算符優先順序
public static void main(String[] args) {
System.out.println(5+12*(3+5)/7.0);
Calculator cal = new Calculator();
String s = "5+12*(3+5)/7";
double result = cal.calculate(s);
System.out.println(result);
}
/**
* 按照給定的表達式計算
* @param expression 要計算的表達式例如:5+12*(3+5)/7
* @return
*/
public double calculate(String expression) {
Stack<String> resultStack = new Stack<String>();
prepare(expression);
Collections.reverse(postfixStack);//將後綴式棧反轉
String firstValue ,secondValue,currentValue;//參與計算的第一個值，第二個值和算術運算符
while(!postfixStack.isEmpty()) {
currentValue = postfixStack.pop();
if(!isOperator(currentValue.charAt(0))) {//如果不是運算符則存入操作數棧中
resultStack.push(currentValue);
} else {//如果是運算符則從操作數棧中取兩個值和該數值一起參與運算
secondValue = resultStack.pop();
firstValue = resultStack.pop();
String tempResult = calculate(firstValue, secondValue, currentValue.charAt(0));
resultStack.push(tempResult);
}
}
return Double.valueOf(resultStack.pop());
}
/**
* 數據准備階段將表達式轉換成為後綴式棧
* @param expression
*/
private void prepare(String expression) {
opStack.push(',');//運算符放入棧底元素逗號，此符號優先順序最低
char[] arr = expression.toCharArray();
int currentIndex = 0;//當前字元的位置
int count = 0;//上次算術運算符到本次算術運算符的字元的長度便於或者之間的數值
char currentOp ,peekOp;//當前操作符和棧頂操作符
for(int i=0;i<arr.length;i++) {
currentOp = arr[i];
if(isOperator(currentOp)) {//如果當前字元是運算符
if(count > 0) {
postfixStack.push(new String(arr,currentIndex,count));//取兩個運算符之間的數字
}
peekOp = opStack.peek();
if(currentOp == ')') {//遇到反括弧則將運算符棧中的元素移除到後綴式棧中直到遇到左括弧
while(opStack.peek() != '(') {
postfixStack.push(String.valueOf(opStack.pop()));
}
opStack.pop();
} else {
while(currentOp != '(' && peekOp != ',' && compare(currentOp,peekOp) ) {
postfixStack.push(String.valueOf(opStack.pop()));
peekOp = opStack.peek();
}
opStack.push(currentOp);
}
count = 0;
currentIndex = i+1;
} else {
count++;
}
}
if(count > 1 || (count == 1 && !isOperator(arr[currentIndex]))) {//最後一個字元不是括弧或者其他運算符的則加入後綴式棧中
postfixStack.push(new String(arr,currentIndex,count));
}
while(opStack.peek() != ',') {
postfixStack.push(String.valueOf( opStack.pop()));//將操作符棧中的剩餘的元素添加到後綴式棧中
}
}
/**
* 判斷是否為算術符號
* @param c
* @return
*/
private boolean isOperator(char c) {
return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' ||c == ')';
}
/**
* 利用ASCII碼-40做下標去算術符號優先順序
* @param cur
* @param peek
* @return
*/
public boolean compare(char cur,char peek) {// 如果是peek優先順序高於cur，返回true，默認都是peek優先順序要低
boolean result = false;
if(operatPriority[(peek)-40] >= operatPriority[(cur) - 40]) {
result = true;
}
return result;
}
/**
* 按照給定的算術運算符做計算
* @param firstValue
* @param secondValue
* @param currentOp
* @return
*/
private String calculate(String firstValue,String secondValue,char currentOp) {
String result = "";
switch(currentOp) {
case '+':
result = String.valueOf(ArithHelper.add(firstValue, secondValue));
break;
case '-':
result = String.valueOf(ArithHelper.sub(firstValue, secondValue));
break;
case '*':
result = String.valueOf(ArithHelper.mul(firstValue, secondValue));
break;
case '/':
result = String.valueOf(ArithHelper.div(firstValue, secondValue));
break;
}
return result;
}
}
public class ArithHelper {
// 默認除法運算精度
private static final int DEF_DIV_SCALE = 16;
// 這個類不能實例化
private ArithHelper() {
}
/**
* 提供精確的加法運算。
*
* @param v1 被加數
* @param v2 加數
* @return 兩個參數的和
*/
public static double add(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
public static double add(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.add(b2).doubleValue();
}
/**
* 提供精確的減法運算。
*
* @param v1 被減數
* @param v2 減數
* @return 兩個參數的差
*/
public static double sub(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
public static double sub(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.subtract(b2).doubleValue();
}
/**
* 提供精確的乘法運算。
*
* @param v1
* 被乘數
* @param v2
* 乘數
* @return 兩個參數的積
*/
public static double mul(double v1, double v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
public static double mul(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(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);
}
public static double div(String v1, String v2) {
java.math.BigDecimal b1 = new java.math.BigDecimal(v1);
java.math.BigDecimal b2 = new java.math.BigDecimal(v2);
return b1.divide(b2, DEF_DIV_SCALE, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供（相對）精確的除法運算。當發生除不盡的情況時，由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");
}
java.math.BigDecimal b1 = new java.math.BigDecimal(Double.toString(v1));
java.math.BigDecimal b2 = new java.math.BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, java.math.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");
}
java.math.BigDecimal b = new java.math.BigDecimal(Double.toString(v));
java.math.BigDecimal one = new java.math.BigDecimal("1");
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double round(String v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
java.math.BigDecimal b = new java.math.BigDecimal(v);
java.math.BigDecimal one = new java.math.BigDecimal("1");
return b.divide(one, scale, java.math.BigDecimal.ROUND_HALF_UP).doubleValue();
}
}