精华内容
下载资源
问答
  • JAVAMath类调用

    千次阅读 2019-05-01 17:21:56
    // Math类中的方法 // Math.nextUp(a);//返回一个比a大一点点的浮点数 // System.out.println(Math.nextUp(2.5)); // Math.nextDown(a);返回一个比a稍微小一点点的数 // System.out.println(Math.nextDown(2.4))...

    // Math类中的方法
    // Math.nextUp(a);//返回一个比a大一点点的浮点数
    // System.out.println(Math.nextUp(2.5));
    // Math.nextDown(a);返回一个比a稍微小一点点的数
    // System.out.println(Math.nextDown(2.4));
    //Math.nextAfter(a,b);返回一个a,b之间与a相邻的浮点数
    // System.out.println(Math.nextAfter(1.5,26));
    // Math.round(x);四舍五入,x为float时返回int型,x为double型时返回long型
    // System.out.println(Math.round(-54.2));
    // Math.rint(x); 四舍五入,返回double类型
    // Math.random();取一个大于等于0同时小于等于1的随机数[0,1],若要取[0,n]之中的随机数,则只需Math.random()*n
    //Math.floor();返回小的值,在x轴上向左靠
    // System.out.println(Math.floor(-2.5));//-3.0
    // Math.ceil();返回大的数,在x轴上向右靠
    // Math.abs(x);求x的绝对值
    // Math.max();
    // Math.min();求最大最小值
    // Math.pow(x,n);计算x的n次方
    // Math.exp(x);计算e的x次方
    // Math.hypot(x,y);计算(x的平方 + y的平方)的平方根
    // Math.cbrt();计算立方根
    // Math.sqrt();计算平方根

    展开全文
  • Java Number & Math

    千次阅读 2018-05-24 13:30:54
    Math 一般地,当需要使用数字的时候,我们通常使用内置数据类型,如:byte、int、long、double 等。实例int a = 5000;float b = 13.65f;byte c = 0x4a;然而,在实际开发过程中,我们经常会遇到需要使用对象,而...

    Java Number & Math 类

    一般地,当需要使用数字的时候,我们通常使用内置数据类型,如:byte、int、long、double 等。

    实例

    int a = 5000;
    float b = 13.65f;
    byte c = 0x4a;

    然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情形。为了解决这个问题,Java 语言为每一个内置数据类型提供了对应的包装类。

    所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。

    Java Number类

    这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类。相似的,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

    下面是一个使用 Integer 对象的实例:(装箱与拆箱)

    Test.java 文件代码:

    public class Test{
        public static void main(String args[]){
            Integer x = 5; // boxes int to an Integer object
            x = x + 10;   // unboxes the Integer to a int
            System.out.println(x);
        }
    }

    以上实例编译运行结果如下:

    15

    当 x 被赋为整型值时,由于x是一个对象,所以编译器要对x进行装箱。然后,为了使x能进行加运算,所以要对x进行拆箱。


    Java Math 类

    Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数。

    Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用。

    Test.java 文件代码:

    public class Test {
        public static void main (String []args) {
            System.out.println("90 度的正弦值:" + Math.sin(Math.PI/2));
            System.out.println("0度的余弦值:" + Math.cos(0));
            System.out.println("60度的正切值:" + Math.tan(Math.PI/3));
            System.out.println("1的反正切值: " + Math.atan(1));
            System.out.println("π/2的角度值:" + Math.toDegrees(Math.PI/2));
            System.out.println(Math.PI);
        }
    }

    以上实例编译运行结果如下:

    90 度的正弦值:1.0
    0度的余弦值:1.0
    60度的正切值:1.7320508075688767
    1的反正切值: 0.7853981633974483
    π/2的角度值:90.0
    3.141592653589793

    Number & Math 类方法

    下面的表中列出的是 Number & Math 类常用的一些方法:

    序号方法与描述
    1xxxValue()
    将 Number 对象转换为xxx数据类型的值并返回。
    2compareTo()
    将number对象与参数比较。
    3equals()
    判断number对象是否与参数相等。
    4valueOf()
    返回一个 Number 对象指定的内置数据类型
    5toString()
    以字符串形式返回值。
    6parseInt()
    将字符串解析为int类型。
    7abs()
    返回参数的绝对值。
    8ceil()
    返回大于等于( >= )给定参数的的最小整数。
    9floor()
    返回小于等于(<=)给定参数的最大整数 。
    10rint()
    返回与参数最接近的整数。返回类型为double。
    11round()
    它表示四舍五入,算法为 Math.floor(x+0.5),即将原来的数字加上 0.5 后再向下取整,所以,Math.round(11.5) 的结果为12,Math.round(-11.5) 的结果为-11。
    12min()
    返回两个参数中的最小值。
    13max()
    返回两个参数中的最大值。
    14exp()
    返回自然数底数e的参数次方。
    15log()
    返回参数的自然数底数的对数值。
    16pow()
    返回第一个参数的第二个参数次方。
    17sqrt()
    求参数的算术平方根。
    18sin()
    求指定double类型参数的正弦值。
    19cos()
    求指定double类型参数的余弦值。
    20tan()
    求指定double类型参数的正切值。
    21asin()
    求指定double类型参数的反正弦值。
    22acos()
    求指定double类型参数的反余弦值。
    23atan()
    求指定double类型参数的反正切值。
    24atan2()
    将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
    25toDegrees()
    将参数转化为角度。
    26toRadians()
    将角度转换为弧度。
    27random()
    返回一个随机数。

    Math 的 floor,round 和 ceil 方法实例比较

    参数Math.floorMath.roundMath.ceil
    1.4112
    1.5122
    1.6122
    -1.4-2-1-1
    -1.5-2-1-1
    -1.6-2-2-1

    floor,round 和 ceil 实例:

    public class Main {
        public static void main(String[] args) {
            double[] nums = { 1.4, 1.5, 1.6, -1.4, -1.5, -1.6 };
            for (double num : nums) {
                test(num);
            }
        }
        private static void test(double num) {
            System.out.println("Math.floor(" + num + ")=" + Math.floor(num));
            System.out.println("Math.round(" + num + ")=" + Math.round(num));
            System.out.println("Math.ceil(" + num + ")=" + Math.ceil(num));
        }
    }

    以上实例执行输出结果为:

    Math.floor(1.4)=1.0
    Math.round(1.4)=1
    Math.ceil(1.4)=2.0
    Math.floor(1.5)=1.0
    Math.round(1.5)=2
    Math.ceil(1.5)=2.0
    Math.floor(1.6)=1.0
    Math.round(1.6)=2
    Math.ceil(1.6)=2.0
    Math.floor(-1.4)=-2.0
    Math.round(-1.4)=-1
    Math.ceil(-1.4)=-1.0
    Math.floor(-1.5)=-2.0
    Math.round(-1.5)=-1
    Math.ceil(-1.5)=-1.0
    Math.floor(-1.6)=-2.0
    Math.round(-1.6)=-2
    Math.ceil(-1.6)=-1.0
    Java Math类

    数字格式化

    在Java中,对没有格式化的数据遵循以下原则:

    如果数值绝对值大于0.001并且小于10000000,Java将以常规小数形式表示。
    如果数值绝对值小于0.001或者大于10000000,使用科学计数法表示。
    为满足实际问题的要求,Java中使用java.text.DecimalFormat来格式化数字。DecimalFormat是NumberFormat的子类,用来格式化十进制数字。一般情况下可以在实例化DecimalFormat对象是传递数字格式,也可以通过DecimalFormat类中的applyPattern()方法来实现数字格式化。


    DecimalFormat类中特殊字符说明:

    #:代表阿拉伯数字,使用特殊字符“#”表示数字的一位阿拉伯数字,如果该位存在数字,则显示字符;如果该位不存在数字,则不显示
    .:小数分隔符或货币小数分隔符
    -:负号
    ,:分组分隔符
    E:分隔科学计数法中的尾数和指数
    %:本符号放置在数字的前缀或后缀,将数字乘以100显示为百分数
    \u2030:本符号放置在数字的前缀或后缀,将数字乘以1000显示为千分数
    \u00A4:本符号放置在数字的前缀或后缀,作为货币记号

    ':本符号为单引号,当上述特殊字符出现在数字中时,应为特殊符号添加单引号,系统会将此符号视为普通符号处理

    DecimalFormat类中除了可设置格式化模式来格式化数字外,还可以使用一些特殊方法对数组进行格式化设置,例如:DecimalFormat myFormat=new DecimalFormat();   //实例化DecimalFormat类对象
    myFormat.setGroupingSize(2);                 //设置将数字分组大小

    myFormat.setGroupingUsed(false);            //设置是否支持分组

    常用数学运算方法

    三角函数方法:

    sin(),cos()等,参数和返回值都是double类型。toRadians(),toDegrees(),角度和弧度相互转换,但结果通常是不精确的。

    指数函数方法:

    Math.exp(x);                    //e的x次幂  
    Math.scalb(x, y);               //x*(2的y次幂)
    Math.log(e);                    //1 以e为底的对数 
    Math.log10(x);                  // 以10为底x的对数  
    Math.log1p(x);                  //Ln(x+ 1) 
    Math.sqrt(x);                   //√(x) x的二次方根  
    Math.cbrt(x);                   // x的立次方根 
    Math.pow(x, y);                 //返回 x的y次幂

    Math.hypot(x, y);               //√(x²+y²),x和y平方和的二次方根 

    取整函数方法:

    Math.ceil(12.3);                   //返回大于等于参数的最小整数13.0  
    Math.floor(12.3);                  //返回小于等于参数的最大整数12.0  
    Math.rint(12.3);                   //返回与参数最接近的整数12.0,如果刚好居中,则取偶数    
    public static int round(float x)   //将参数加上0.5后返回与参数最近的整数。  

    public static long round(double x) //将参数加上0.5后返回与参数最近的整数,然后强制转换为long型

    取最大值、最小值、绝对值等方法:

    Math.max(x, y);                 //返回x、y中较大的那个数  
    Math.min(x, y);                 //返回x、y中较小的那个数  
    Math.abs(-12.3);                //12.3  返回这个数的绝对值
    Math.copySign(1.23, -12.3);     //-1.23,返回第一个参数的量值和第二个参数的符号   

    Math.signum(x);                 //如果x大于0则返回1.0,小于0则返回-1.0,等于0则返回0  

    随机数

    Math.random()方法:

    在Math类中存在一个random()方法,用于产生随机数字,这个方法默认生成大于等于0.0小于1.0的double型随机数。
    利用random()方法也可以随机生成字符,可以使用如下代码生成字符'a'~'z'之间的随机字符。
    (char)('a' + Math.random() * ('z' - 'a' + 1));
    通过上述表达式可以求出更多的随机字符,如'A'~'Z'之间的随机字符,进而可以推理到求任意两个字符之间的随机字符,可以使用如下语句表示:
    (char)(char1 + Math.random() * (char2 - char1 + 1));
    random()方法返回得值实际上是伪随机数,它是通过复杂的计算而得到的一系列的数。

    该方法是通过当前时间为种子(作为随机数生成方法的参数),来得到每次执行后的不同的随机数。

    Random类:

    除了Math类中的random()方法,Java还提供了一种可以获取随机数的方式,就是java.util.Random类。可以通过实例化一个Random对象创建一个随机数生成器。+A3:A16A3:A15A3:A14A3:A13A3:A14A3:A15
    Random r = new Random();  //其中r是Random对象
    以这种方式实例化对象时,Java编译器以系统当前时间作为随机数生成器的种子,因为每时每刻的时间不可能相同,所以产生的随机数将不同。
    但是如果运行速度太快,也会产生两次运行结果相同的随机数。同时也可以在实例化Random类对象时,设置随机数生成器的种子。
    Random r = new Random(seedValue);  //seedValue是随机数生成器的种子
    Random类常用方法:
    public int nextInt():返回一个随机整数;
    public int nextInt(int n):返回大于等于0小于n的随机整数;
    public long nextLong():返回一个随机长整型值;
    public boolean nextBoolean():返回一个随机布尔型值;
    public float nextFloat():返回一个随机浮点型值;
    public double nextDouble():返回一个随机双精度型值;

    public double nextGaussian():返回一个概率密度为高斯分布的双精度值;

    大数字运算BigInteger类型:

    BigInteger类型的数字范围较Integer类型的数字范围要大得多。Integer是int的包装类,BigInteger类是来处理更大的数字。
    BigInteger支持任意精度的整数,也就是说在运算中BigInteger类型可以准确地表示任何大小的整数值而不会丢失任何信息。
    当使用BigInteger类时,可以实例化一个BigInteger对象,并自动调用相应的构造函数。
    BigInteger类具有很多构造函数,但最直接的一种方式是参数以字符串形式要代表要处理的数字。
    public BigInteger(String val)     其中,val是十进制字符串。
    如果将2转换为BigInteger类型,可以使用一下语句进行初始化操作:
    BigInteger twoInstance = new BigInteger("2");    //将十进制2转换为BigInteger形式,参数2的双引号不能省略,因为参数是以字符串的形式存在的。


    BigInteger类常用方法:
    public BigInteger add(BigInteger val)、subtract(BigInteger val):做加法、减法运算
    public BigInteger multiply(BigInteger val)、divide(BigInteger val):做乘法、除法运算
    public BigInteger remainder(BigInteger val):做取余运算
    public BigInteger[] divideAndRemainder(BigInteger val):用数组返回余数和商,结果数组中第一个值为商,第二个值为余数
    public BigInteger pow(int exponent):进行取参数的exponent次方操作
    public BigInteger negate():取相反数
    public BigInteger shiftLeft(int n)、shiftRight(int n):将数字左移n位,如果n为负数,做右移操作、将数字右移n位,如果n是负数,做左移操作
    public BigInteger and(BigInteger val)、or(BigInteger val):做与、做或操作
    public int compareTo(BigInteger val):做数字比较操作
    public boolean equals(Object x):当参数x是BigInteger类型的数字并且数值相等时,返回true

    public BigInteger min(BigInteger val)、max(BigInteger val):返回较小、较大的数值

    大数字运算BigInteger类型,BigDecimal类型:

    BigDecimal和BigInteger都能实现大数字的运算,不同的是BigInteger加入了小数的概念。一般的float型和double型数据只能用来做科学计算或工程计算。
    但由于在商业计算中要求数字精度比较高,所以要用到java.math.BigDecimal类。BigDecimal支持任何精度的定点数,可以用它来精确计算货币值。
    在BigDecimal类中常用的两个构造方法如下:
    "public BigDecimal(double val):实例化时将双精度型转换为BigDecimal类型
    public BigDecimal(String val):实例化时将字符串型转换为BigDecimal类型"
    public BigDecimal add(BigDecimal augend)、subtract(BigDecimal subtrahend)、multiply(BigDecimal multiplicand):做加、减、乘法操作
    public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):做除法操作,方法中参数分别代表:除数、商的小数点后的位数、近似处理模式
    BigDecimal类型的数字可以用来做超大的浮点数的运算,其中除法运算是最复杂的,因为在除不尽的情况下末位小数点的处理是需要考虑的。
    roundingMode模式有多种设置,用于返回商末位小数点的处理,模式名称与含义如下:
    BigDecimal.ROUND_UP:商的最后一位如果大于0,则向前进位,正负数都如此
    BigDecimal.ROUND_DOWN :商的最后一位无论是什么数字都省略
    BigDecimal.ROUND_CEILING:商如果是整数,按照ROUND_UP模式处理;如果是负数,按照ROUND_DOWN模式处理。这种模式的处理都会使近似值大于等于实际值
    BigDecimal.ROUND_FLOOR:与ROUND_CEILING模式相反,商如果是整数,按照ROUND_DOWN模式处理;商如果是负数,按照ROUND_UP模式处理,这种模式的处理都会使得近似值小于等于实际值
    BigDecimal.ROUND_HALF_DOWN:对商进行四舍五入操作,如果商最后以为小于等于5,则做舍弃操作;如果最后一位大于5,则做进位操作
    BigDecimal.ROUND_HALF_UP:对商进行四舍五入操作,如果商最后以为小于5,则做舍弃操作;如果最后一位大于等于5,则做进位操作
    BigDecimal.ROUND_HALF_EVEN:如果商的倒数第二位为奇数,则按照ROUND_HALF_UP处理;如果为偶数,则按照ROUN_HALF_DOWN处理。如7.5处理后就是8,8.5处理后就是8

    展开全文
  • Java中的Math类和日期类详解

    千次阅读 2017-03-10 20:12:48
    Math类是定义了一系列的数学运算方法,是使用static修饰的方法,表示可以通过Math类直接访问。我们在开发中一般只需要关注两个:  ·四舍五入:  ·取得随机数 四舍五入 API文档中描述: round ...

    Math类是定义了一系列的数学运算方法,是使用static修饰的方法,表示可以通过Math类直接访问。我们在开发中一般只需要关注两个:

             ·四舍五入:

             ·取得随机数

    四舍五入

    API文档中描述:

    round

    public static int round(float a)

    返回最接近参数的 int。结果将舍入为整数:加上 1/2,对结果调用 floor 并将所得结果强制转换为 int 类型。换句话说,结果等于以下表达式的值:

    (int)Math.floor(a + 0.5f)

    特殊情况如下:

    ·         如果参数为 NaN,那么结果为 0。

    ·         如果结果为负无穷大或任何小于等于 Integer.MIN_VALUE 的值,那么结果等于 Integer.MIN_VALUE 的值。

    ·         如果参数为正无穷大或任何大于等于 Integer.MAX_VALUE 的值,那么结果等于 Integer.MAX_VALUE 的值。

     

    范例:

    public class MathDemo {
    	public static void main(String[] args) {
    		double  d = 100.53;
    		
    		int i = (int)Math.round(d);//四舍五入
    		
    		System.out.println(i);
    	}
    }
    

    输出结果为101.

    对于金额来说的话,一般都是取两位小数,这时的做法是:

    public class Demo {

        public static void main(String[] args) {

           double  d = 10540.53554353454;

          

           double i = Math.round(d*100)/100.00;//四舍五入

          

           System.out.println(i);

        }

    }

     

    取随机数

    API文档中描述:

    random

    public static double random()

    返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。

    第一次调用该方法时,它将创建一个新的伪随机数生成器,与以下表达式完全相同

    new java.util.Random

    之后,新的伪随机数生成器可用于此方法的所有调用,但不能用于其他地方。

    此方法是完全同步的,可允许多个线程使用而不出现错误。但是,如果许多线程需要以极高的速率生成伪随机数,那么这可能会减少每个线程对拥有自己伪随机数生成器的争用。

     

    范例:

    public class MathDemo {
    	public static void main(String[] args) {		
    		for (int i = 0; i < 100; i++) {
    			double d = Math.random();//取0-1之间的随机数
    			int x = (int)Math.round(d*10);
    			System.out.print(x+"\t");
    		}
    	}
    }
    

    输出结果为范围在0-10的随机整数数。

    日期类常用的有三个,Date类,Calendar(日历)类和日期格式转换类(DateFormat)

    Date类中的大部分的方法都已经过时,一般只会用到构造方法取得系统当前的时间。

    public class DateDemo {
    	public static void main(String[] args) {
    		Date date = new Date();
    		System.out.println(date);
    	}
    }
    

    结果输出当前系统的时间:Fri Mar 10 16:50:37 CST 2017
    我们可以看到,这种格式的时间我们看着并不习惯,所以在展示时间的时候必须要转换一下输出格式,这时候我们要用到日期格式转换类DateFormat了。
    public class FormatDemo {
        public static void main(String[] args) {
    	Date d=new Date();
    	System.out.println(d);
    	Format f=new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
    	String s=f.format(d);
    	System.out.println(s);
        }
    }
    

    这时输出时间为:2017-03-10 04-54-06

    这样就看着很舒服了。

     

    Calendar

    Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法。

    可以使用三种方法更改日历字段:set()add()roll()

    1,set(f, value) 将日历字段f 更改为value

    2,add(f, delta)delta 添加到f 字段中。

    3,roll(f, delta)delta 添加到f 字段中,但不更改更大的字段。

     

    范例:

    public class Test {
        public static void main(String[] args) {
    	Calendar c=new GregorianCalendar();
    	c.set(Calendar.DAY_OF_MONTH,1);
    	System.out.println("输出的是本月第一天");
    	System.out.println((c.get(Calendar.MARCH)+1)+"月的"+c.get(Calendar.DAY_OF_MONTH)+"号");
    	c.roll(Calendar.DAY_OF_MONTH,-1);
    	System.out.println("输出的是本月最后一天");
    	System.out.println((c.get(Calendar.MARCH)+1)+"月的"+c.get(Calendar.DAY_OF_MONTH)+"号");
        }
    }
    

    输出结果为:

    输出的是本月第一天

    3月的1号

    输出的是本月最后一天

    3月的31号

    Roll方法在操作的过程中,一号天数减一之后,直接又返回本月的最后一天,日期变动在本月内循环而不会去改变月份,即不会更改更大的字段。

    比较add方法:

    public class Test {
        public static void main(String[] args) {
    	Calendar c=new GregorianCalendar();
    	c.set(Calendar.DAY_OF_MONTH,1);
    	System.out.println("输出的是本月第一天");
    	System.out.println((c.get(Calendar.MARCH)+1)+"月的"+c.get(Calendar.DAY_OF_MONTH)+"号");
    	c.add(Calendar.DAY_OF_MONTH,-1);
    	System.out.println("输出的是上个月最后一天");
    	System.out.println((c.get(Calendar.MARCH)+1)+"月的"+c.get(Calendar.DAY_OF_MONTH)+"号");
        }
    }
    

    输出结果为:

    输出的是本月第一天

    3月的1号

    输出的是本月最后一天

    2月的28号

    可以看出在三月一号的基础上减去一之后,自动月份自动变到了二月。这个时roll方法和ad方法的区别。




    展开全文
  • java中的Math类

    千次阅读 2011-12-08 18:04:01
    Java中的Math类  Java中的Math类属于java.lang包中,Math的所有方法均用static声明,所以使用该类中的方法时,可以直接使用包名·方法名,如:Math.sin();Math 类包含用于执行基本数学运算的方法,如初等指数、...

     

    Java中的Math类

      Java中的Math类属于java.lang包中,Math的所有方法均用static声明,所以使用该类中的方法时,可以直接使用包名·方法名,如:Math.sin();Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。

      首先,java.lang.Math中的四舍五入,上,下取整方法:

    四舍五入:

    round(float a)
              返回最接近参数的 int。

         System.out.println(Math.round(5.4d));

         System.out.println(Math.round(5.5d));

         输出结果为:5

                              6

    向上取整:

    ceil(double a)
              返回最小的(最接近负无穷大)double 值,该值大于等于参数,并等于某个整数。

        System.out.println(Math.ceil(5.4d));

        System.out.println(Math.ceil(5.5d));
         输出结果为:6.0

                             6.0

    向下取整:

    floor(double a)
              返回最大的(最接近正无穷大)double 值,该值小于等于参数,并等于某个整数。

        System.out.println(Math.floor(5.4d));

        System.out.println(Math.floor(5.5d));
          输出结果为:5.0

                              5.0

      其中,在使用此类中的三角函数方法时,应注意方法的灵活运用,及传递合适的参数。

      以sin30°为例:JDK中Math.sin(double a)的源代码:

    public static double sin(double a)

    参数:

        a - 以弧度表示的角。

    因此此时首先要把参数30转换为是弧度表示的角。使用方法sin(30*Math.PI/180),PI在数学方法中为π,而此时的π在角度里为180°,Math.PI/180就为1°,所以30*Math.PI/180就相当于了30°。

       System.out.println(Math.sin(30*Math.PI/180));

     

      输出结果为:0.49999999999999994

    因为Math类中的方法直接计算出来的值均为近似值,若想得到精确值,需要使用Math中的四舍五入方法round()。

    即为:

       double sin30 = Math.round(Math.sin(30*Math.PI/180)*100);

       System.out.println(“sin30=”+sin30/100);
        输出结果为:sin30 °= 0.5

    查看Math.round(double a)的源代码:

    public static long round(double a)

    返回最接近参数的 long。结果将舍入为整数:加上 1/2,对结果调用 floor 并将所得结果强制转换为 long 类型。换句话说,结果等于以下表达式的值:

    (long)Math.floor(a + 0.5d)。即Math.sin(30*Math.PI/180)= 0.49999999999999994,乘以100后得49.99999999,然后49.99999999加上0.5得50.49999999,此时再利用Math类中的另一方法floor(),向下取整,得到50.0,将50.0返回给double sin30,然后sin30°=sin30/100,整除以100,即得到sin30°的精确值0.50.此时我们事先知道sin30°的结果为一个小于1的小数,故使用round()方法,乘以100,四舍五入,然后再除去100.

      同理,当求反正弦时,如:asin0.5 Math.asin(0.5)*(180/Math.PI),此时的PI即π为圆周率的值,所以(180/Math.PI)得到的就是一弧度值,而后Math.asin(0.5)再乘以该一弧度的值,得到的就是弧度值,此时再利用round()方法,Math.round(Math.asin(0.5)*(180/Math.PI)*100),结果在整除以100即得到asin0.5的精确值为30°。

      当我们预测到结果的整数部分为一位或0的小数时,我们若需取得精确值可使用round()的四舍五入方法,同时计算时需要使用先乘以100,后整除以100的操作。倘若结果的整数部分为两位及其以上时,此时使用round()四舍五入方法,既不必使用先乘以100,后才整除以100的操作。因为四舍五入方法四舍五入之后进的是整数位,即整数位的首位加1。

     

     

     

    展开全文
  • 1、JavaMath类常用方法总结  JavaMath类常用的方法有:Math.ceil()、 Math.floor()、 Math.round()、 Math.abs()、 Math.sqrt()、 Math.pow();  JavaMath类中定义的特殊数据有: Math.PI(圆周率)、 Math...
  • JAVA基础(Math类

    万次阅读 2019-06-16 17:59:41
    1,Math类概述 类包含用于执行基本数学运算的方法 Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。 Math所有类都是静态的。可以直接类名。调用。 2,成员方法 ...
  • Java中的Math类(随机数)和函数

    千次阅读 2018-01-02 20:03:41
    Java中的Math类(随机数)和函数及函数的重载 Math类(随机数) Math中,随机数的代码是:random. 也就是 Math.random(); 这时一个 返回的是[0,1)double类型的值 是一个伪随机数 伪随机数就是按照一定规则去随机的数...
  • Java Math类

    千次阅读 2018-03-24 15:06:49
    Math 的方法都被定义为 static 形式,通过 Math 可以在主函数中直接调用。public class JavaMath { public static void main(String[] args) { System.out.println("90 度的正弦值:" + Mat...
  • java math类和BigDecimal 类

    千次阅读 2018-05-16 16:55:56
    java math类 Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数,Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用Java Math类中的常用方法:...
  • 带有静态方法的类(java中的math类

    千次阅读 2013-07-31 10:00:33
    带有静态方法的类通常(虽然不一定是这样)不打算被初始化。 可以用私有构造函数来限制非抽象类被初始化。...例如,java中的math类。它让构造函数标记为私有,所以你无法创建Math的实例。但Math类却不是静态类。
  • java常用类-Math类

    千次阅读 2019-07-28 09:53:15
    Math类是一个数学工具类方法,里面有很多静态工具方法;方便开发者直接调用 下面列举几个常见的方法,其它方法可查看API文档 public class testMath { public static void main(String[] args) { System.out....
  • javaMath类与Random类的用法

    千次阅读 2015-10-11 12:58:17
    一.Math类 表示数学操作,比如求平方根、四舍五入等,它是java.lang包中的类 public final class Math extends Object Math类中的方法都是静态方法,直接使用“类.方法名称()”就可以调用了 public class MathDemo...
  • Java学习-Random类和Math类

    千次阅读 2020-08-30 20:44:32
    Random 1 、什么是Random 此类的实例用于生成伪随机数 Random中实现的随机算法是伪随机,也就是有规则的随机。在进行随机时,随机算法的起源数字称为种子数(seed),在种子数的基础上进行一定的变换,从而产生...
  • Java中的math类的常用方法及用法说明

    千次阅读 2017-06-24 07:38:41
    package java5;public class MathNum {public static void main(String[] args){double a=12.81;int b=(int)a;System.out.println("强制类型转换:"+b);long c=Math.round(a);//调用round方法,四舍五入System.out....
  • java-Math类Random方法获取随机数案例

    千次阅读 2017-06-22 23:12:15
    借助javaMath类Random方法获取随机数案例: package day08; /* * 需求: * 通过使用javaAPI查询使用Math类的使用方法 * 获取一个原始随机数(不加条件) * 来获取一个1-100的随机数 * 获取100个1-100之间的...
  • Java Math类的常用方法

    2020-03-04 19:28:46
    Math 位于 java.lang 包,它的构造方法是 private 的,因此无法创建 Math 的对象,并且 Math 中的所有方法都是方法,可以直接通过类名来调用它们。 下面详细介绍该的常量及数学处理方法。 静态常量 Math ...
  • Java.lang.Math类详解

    千次阅读 2019-03-05 09:24:14
    Math类位于Java.lang包中,包含用于执行基本数学运算的方法!Math类的所有执行方法都是静态方法,可以直接使用类名.方法名调用,如:Math.round() 常用的方法:Math.round() 返回最接近参数的 int,它表示&quot;四...
  • Math类直接继承Object类:public final class Math ...java.lang包内有一个名为StrictMath类,StrictMath类和Math类有很多同名方法。在默认情况下,很多 Math 类方法直接调用 StrictMath中的等价方法来完成。 为...
  • Math类: 1,java.lang.Math类中包含基本的数字操作,如指数、对数、平方根和三角函数。... 3,java.lang.Math类中包含E和PI两个静态常量,以及进行科学计算的类(static)方法,可以直接通过类名调用。 函数public
  • package ...import java.math.BigInteger; import java.util.Scanner; public class bigData { public static void main(String[] args) { Scanner s=new Scanner(System.in); String str1=null,...
  • from:... 一丶Java.text.DecimalFormat与NumberFormat  首先 Java.text.DecimalFormat指的是DecimalFormatJava.text包中. 其中DecimalFormat是NumberFormat的子类. 这个的作用...
  • 1、Math类的介绍 java.lang.Math 类提供了一些基本数字运算和几何运算的方法。此类中的所有方法都是静态的。这个类是 final 类,因此没有子类。 Math类的常用方法: 方法 说明 static double sin(double a) ...
  • JAVA Math类的数学计算函数

    千次阅读 2016-09-06 17:17:19
    java.lang.Math类中包含基本的数字操作,如指数、对数、平方根和三角函数。
  • JAVA常用Math

    千次阅读 2015-12-26 18:10:21
    Java中提供了Math类方便我们进行数学计算。 Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。 与 StrictMath 类的某些数学方法不同,并非 Math 类所有等价函数的实现都定义为返回...
  • javamath类方法简介

    千次阅读 2013-01-23 11:04:57
    Math类: ... java.lang.Math类中包含基本的数字操作,如指数、对数、平方根和三角函数。  java.math是一个包,提供用于执行任意精度整数(BigInteger)算法和任意精度小数(BigDecimal)算法的类。
  • JAVAMath类常用数学运算记录

    千次阅读 2016-05-22 16:39:10
    Math中定义了许多的方法,且这些方法均为static类型,通过Math类就能直接调用。  调用形式:Math.方法名 例如,我要进行e运算,那么我直接调用Math.exp(double 类型 数值);即可。 常用分类如下: 1.三角函数方法:...
  • 三、Math 四、Arrays 五、BigInteger 六、BigDecimal 一、基本类型包装 在实际开发中,往往需要将数据转换成字符串类型进行存储,会根据需要转换成指定的基本数据类型,因此,Java将基本数据类型...
  • javaMath的使用简单介绍

    千次阅读 2014-03-20 17:15:34
    Math类简介 Math继承于java.lang.Object类。Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。   字段摘要 static double E  比任何其他值都更接近 e(即自然对数的底数)的...
  • java.math.BigDecimalmultiply的使用

    万次阅读 多人点赞 2018-04-25 09:52:48
    java.math.BigInteger.multiply(BigInteger val) 返回一个BigInteger,其值是 (this * val).声明以下是java.math.BigInteger.multiply()方法的声明public BigInteger multiply(BigInteger val)参数val - 通过此...
  • 目录(一)String类(1.1)String类的常用属性和方法(1.2)代码实现(二)Math类(2.1)Math类的常用方法(2.2)代码实现(三)Arrays类(3.1)Arrays类的常用方法(3.2)代码实现(四)Random类(四)日历类(五)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,102
精华内容 65,240
关键字:

java里如何调用math类

java 订阅