这个程序的功能是输入投资额，投资年限，然后计算每年总收入，能编译，但是在输入年限str2按Enter之后提示数据格式错误，请帮忙看一下，谢谢！importjava.io.IOException;classInvest...
这个程序的功能是输入投资额，投资年限，然后计算每年总收入，能编译，但是在输入年限str2按Enter之后提示数据格式错误，请帮忙看一下，谢谢！
import java.io.IOException;
class Investment
{
public static void main(String [] args) throws IOException
{
String str1=new String();
String str2=new String();
System.out.println("请输入您的投资金额：");
char tr1=(char)System.in.read();
while(tr1>='0' && tr1<='9')
{
str1=str1+tr1;
tr1=(char)System.in.read();
}
System.in.read();
int e1=Integer.parseInt(str1);
System.out.println("您输入的金额为："+e1);
System.out.print("请按”Enter“键确认！");
System.in.read();
System.out.println("请输入您的投资年限：");
char tr2=(char)System.in.read();
while(tr2>='0' && tr2<='9')
{
str2=str2+tr2;
tr2=(char)System.in.read();
}
System.in.read();
int e2=Integer.parseInt(str2);   //提示有问题
System.out.println("您输入的投资年限为："+str2);
System.out.print("请按”Enter“键确认！");
System.in.read();
double sum=0.0;
double r=0.12;
for (int i=1;i<=e2;i++)
{
sum=e1+Math.pow((1+r),i);
System.out.println("第"+i+"年"+"的总收益为："+sum);
}
}
}
我试过了，会输出捕获异常时输出的那句话，所以这句应该不是这的问题吧。。。
那为什么上面的str1那的System.in.read()
我正因为是上面输入两句要按两下enter键，所以下面才没有加第二句System.in.read()的，没想到问题会出在这。
展开

js,java浮点数运算错误及应对方法
一,浮点数为什么会有运算错误
IEEE 754 标准规定了计算机程序设计环境中的二进制和十进制的浮点数自述的交换、算术格式以及方法.
现有存储介质都是2进制。2进制的进制基数是2，那么一个数字只要被因素包含大于2的质数的数除，都会产生无限循环小数。无限循环小数和无理数都无法，和非无限循环的有理数一起用同一种方式存储到存储介质上的同时还保持计算的兼容性。
对于无限循环小数，可以设计一种格式存储到介质上，但是同时又要和非无限循环的有理数能够计算，效率应该会变得非常低下。 对于无理数，小数位的数字没有规律可循，所以根本无法保存精确值，只能保存近似值。
高精度计算，一般可以将数字转发成string, 去掉小数点，按位计算再保存回string，再加回小数点。
二,错误举例
document.write (0.01 + 0.05);  //输出结果为0.060000000000000005
document.write (0.09 + 0.01);  //输出结果为0.09999999999999999
document.write(11*22.9);     //输出结果为251.89999999999998
三,js如何应对
扩大倍数法:有多少位小数就扩大10的n次方
document.write((0.01*100+0.09*100)/100); //输出结果为0.1
四舍五入法:
document.write((0.01+0.09).toFixed(2)); //保留2位小数,输出结果为0.10
document.write(Math.round((0.01+0.09)*100)/100); //输出结果为0.1
四,java如何应对
扩大倍数法:有多少位小数就扩大10的n次方
System.out.println((0.01*100+0.09*100)/100); //输出结果为0.1
四舍五入法:
System.out.println(Math.rint(0.01*100+0.09*100)/100); //输出结果为0.1
System.out.println(Math.round(0.01*100+0.09*100)/100); //输出结果为0.1
System.out.println(new  BigDecimal(0.099).setScale(2,  RoundingMode.HALF_UP).doubleValue());  //输出结果为0.10
备注: Java支持7中舍入法
1、 ROUND_UP：远离零方向舍入。向绝对值最大的方向舍入，只要舍弃位非0即进位。
2、 ROUND_DOWN：趋向零方向舍入。向绝对值最小的方向输入，所有的位都要舍弃，不存在进位情况。
3、 ROUND_CEILING：向正无穷方向舍入。向正最大方向靠拢。若是正数，舍入行为类似于ROUND_UP，若为负数，舍入行为类似于ROUND_DOWN。Math.round()方法就是使用的此模式。
4、 ROUND_FLOOR：向负无穷方向舍入。向负无穷方向靠拢。若是正数，舍入行为类似于ROUND_DOWN；若为负数，舍入行为类似于ROUND_UP。
5、 HALF_UP：最近数字舍入(5进)。这是我们最经典的四舍五入。
6、 HALF_DOWN：最近数字舍入(5舍)。在这里5是要舍弃的。
7、 HALF_EVEN：银行家舍入法。银行家舍入法.
附录一:js封装四则运算
//除法函数，用来得到精确的除法结果//说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。//调用：accDiv(arg1,arg2)//返回值：arg1除以arg2的精确结果
functionaccDiv(arg1,arg2){var t1=0,t2=0,r1,r2;try{t1=arg1.toString().split(".")[1].length}catch(e){}try{t2=arg2.toString().split(".")[1].length}catch(e){}with(Math){
r1=Number(arg1.toString().replace(".",""))
r2=Number(arg2.toString().replace(".",""))return (r1/r2)*pow(10,t2-t1);
}
}//给Number类型增加一个div方法，调用起来更加方便。
Number.prototype.div = function(arg){return accDiv(this, arg);
}//乘法函数，用来得到精确的乘法结果//说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。//调用：accMul(arg1,arg2)//返回值：arg1乘以arg2的精确结果
functionaccMul(arg1,arg2)
{var m=0,s1=arg1.toString(),s2=arg2.toString();try{m+=s1.split(".")[1].length}catch(e){}try{m+=s2.split(".")[1].length}catch(e){}return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}//给Number类型增加一个mul方法，调用起来更加方便。
Number.prototype.mul = function(arg){return accMul(arg, this);
}//加法函数，用来得到精确的加法结果//说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。//调用：accAdd(arg1,arg2)//返回值：arg1加上arg2的精确结果
functionaccAdd(arg1,arg2){varr1,r2,m;try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))return (arg1*m+arg2*m)/m
}//给Number类型增加一个add方法，调用起来更加方便。
Number.prototype.add = function(arg){return accAdd(arg,this);
}//减法函数，用来得到精确的减法结果//说明：javascript的减法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。//调用：accSubtr(arg1,arg2)//返回值：arg1减去arg2的精确结果
functionaccSubtr(arg1,arg2){varr1,r2,m,n;try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));//动态控制精度长度
n=(r1>=r2)?r1:r2;return ((arg1*m-arg2*m)/m).toFixed(n);
}//给Number类型增加一个subtr 方法，调用起来更加方便。
Number.prototype.subtr = function(arg){return accSubtr(arg,this);
}
附录二:java工具类Arith
工具类Arith来简化操作。它提供以下静态方法，包括加减乘除和四舍五入：public static double add(double v1,doublev2)public static double sub(double v1,doublev2)public static double mul(double v1,doublev2)public static double div(double v1,doublev2)public static double div(double v1,double v2,intscale)public static double round(double v,intscale)
源文件Arith.java：importjava.math.BigDecimal;/*** 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
* 确的浮点数运算，包括加减乘除和四舍五入。*/
public classArith{//默认除法运算精度
private static final int DEF_DIV_SCALE = 10;//这个类不能实例化
privateArith(){
}/*** 提供精确的加法运算。
*@paramv1 被加数
*@paramv2 加数
*@return两个参数的和*/
public static double add(double v1,doublev2){
BigDecimal b1= newBigDecimal(Double.toString(v1));
BigDecimal b2= newBigDecimal(Double.toString(v2));returnb1.add(b2).doubleValue();
}/*** 提供精确的减法运算。
*@paramv1 被减数
*@paramv2 减数
*@return两个参数的差*/
public static double sub(double v1,doublev2){
BigDecimal b1= newBigDecimal(Double.toString(v1));
BigDecimal b2= newBigDecimal(Double.toString(v2));returnb1.subtract(b2).doubleValue();
}/*** 提供精确的乘法运算。
*@paramv1 被乘数
*@paramv2 乘数
*@return两个参数的积*/
public static double mul(double v1,doublev2){
BigDecimal b1= newBigDecimal(Double.toString(v1));
BigDecimal b2= newBigDecimal(Double.toString(v2));returnb1.multiply(b2).doubleValue();
}/*** 提供(相对)精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
*@paramv1 被除数
*@paramv2 除数
*@return两个参数的商*/
public static double div(double v1,doublev2){returndiv(v1,v2,DEF_DIV_SCALE);
}/*** 提供(相对)精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
*@paramv1 被除数
*@paramv2 除数
*@paramscale 表示表示需要精确到小数点以后几位。
*@return两个参数的商*/
public static double div(double v1,double v2,intscale){if(scale<0){throw newIllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1= newBigDecimal(Double.toString(v1));
BigDecimal b2= newBigDecimal(Double.toString(v2));returnb1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}/*** 提供精确的小数位四舍五入处理。
*@paramv 需要四舍五入的数字
*@paramscale 小数点后保留几位
*@return四舍五入后的结果*/
public static double round(double v,intscale){if(scale<0){throw newIllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b= newBigDecimal(Double.toString(v));
BigDecimal one= new BigDecimal("1");returnb.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
};

Java数字小游戏异常处理-置用户于控制之下
前段时间发了一个猜数字的小游戏，有很多的问题，Java是面向对象的一个程序语言，用户可能是一个计算机的大神也有可能是一个计算机的小白，这就会造成用户在输入的情况下造成输入错误，让输入数字他可能不小心输入一个字母进去，这就会造成程序的终止及报错。这就需要Java的异常处理  try{}catch{}finally{}

要置用户于控制之下。好了看新盖的代码：
package cn.com.www;
import java.io.IOException;
import java.util.*;
public class Test03 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a,b=0;	
		boolean c=true;
		Scanner sc =new Scanner(System.in);
		Scanner sc2 =new Scanner(System.in);
		do
		{
			a=new Random().nextInt(10);
			sc = new Scanner(System.in);	
				while(true)
				{
					try {
					System.out.println("输入一个数");
				    b=sc.nextInt();	
				    try {
				    	while(true) {
				    		while(a!=b)                                                                    
						   {
							if(b>a)
							{
								System.out.println("猜大了");
							}
							else
							{
								System.out.println("猜小了");			
							}
							System.out.println("再猜一次");
							b=sc.nextInt();
						   }		    	 	
				    	   System.out.println("猜对啦");
				    	   System.out.println("是否继续游戏Y/N");
							sc2 = new Scanner(System.in);
							String t=sc2.next();
							if(t.equals("Y"))
							{
								c=true;
							}
							else if(t.equals("N"))
							{
								c=false;
							}
				    		break;
				    	}
				    }catch(InputMismatchException e){
							
							e.printStackTrace();	
							System.out.println("输入错误,重新输入");					
						}
					}catch(Exception e){
					//e.getMessage();
								
					e.printStackTrace();
					System.out.println("输入错误,重新输入");
				}	
				
					
					break;
					}
		}while(c);
	}
}

```无论用户是在一开始输入错误和运行中输入错误，都会及时处理不会造成程序的终止，而且会提醒用户的错误。

JAVA编程语言会遵循由括号显示表示和操作符优先级隐士表示的计算顺序。
Java编程语言的实现不应该利用代数特性，例如应用结合律来重写表达式，使其具有更方法的计算顺序，除非可以证明代替表达式与被代替的表达式在取值上和在可观察的副作用上是等价的，即使在面临多线程执行时也是如此，而且对于所有可能涉及其中的计算值都是如此。
在计算浮点的情况中，这条规则也会应用与无穷值和非数字NaN值。
例如：！（x<y）不能写作x>=y,因为如果x或者y是NaN，那么这些表达式具有不同的值。
特别的，看起来满足数据上的结合律的浮点计算，不可能满足计算结合律，这种计算必须不能被朴素的重排序。
例1：
public class MainTest1 {

	public static void main(String[] args) {
		double d=8E+307;
		System.out.println(4.0*d*0.5);
		System.out.println(2.0*d);
	}
}
执行结果：
Infinity
1.6E308
因为第一个表达式上溢了，而第二个不会。
相比之下，整数加法和乘法在java编程语言中可证明是满足结合律的。
例如表达式a+b+c，其中a、b、c都是局部变量，产生的结果总是与（a+b）+c或a+（b+c）计算的结果相同。如果在代码中附近还有表达式b+c，那么java编译器可以使用这个公共子表达式。