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();
}
}