精华内容
下载资源
问答
  • Java除法运算(保留小数)

    万次阅读 多人点赞 2018-04-17 14:29:03
    编程的人都知道,java中的“/”、“%”运算,其中前者为取整,... * TODO 除法运算,保留小数 * @author 袁忠明 * @date 2018-4-17下午2:24:48 * @param a 被除数 * @param b 除数 * @return 商 */ pu...

    编程的人都知道,java中的“/”、“%”运算,其中前者为取整,后者取余数。那么有没有快捷的运算方法取正常的运算结果呢?

    查了资料,发现很简单。代码如下:

    	/**
    	 * TODO 除法运算,保留小数
    	 * @author 袁忠明
    	 * @date 2018-4-17下午2:24:48
    	 * @param a 被除数
    	 * @param b 除数
    	 * @return 商
    	 */
    	public static String txfloat(int a,int b) {
    	    // TODO 自动生成的方法存根
    	 
    	    DecimalFormat df=new DecimalFormat("0.00");//设置保留位数
    
    	    return df.format((float)a/b);
    	   
    	}

    展开全文
  • Java除法运算的陷阱

    千次阅读 2015-08-08 22:41:32
    Java除法运算的陷阱 2009-12-21 10:27:25 标签:Java 除法 休闲 职场 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。...
    Java除法运算的陷阱
    2009-12-21 10:27:25
    标签: Java  除法  休闲  职场
    原创作品,允许转载,转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 http://lavasoft.blog.51cto.com/62575/247030
    Java除法运算的陷阱
     
    除法运算谁不会啊,很多人不屑一顾,真是无知者无畏!
    其实除法、求余运算有一些陷阱。一旦计算发生了问题,还很不好找。不好找的原因主要是问题的偶然性太强,如果你知道可能发生什么问题,你的代码就可以写得更安全。
     
    数学除法规定,0不能做除数,因为会得到一个无穷大数据。
     
    西面看看Java中如何处理这些特殊情况:
     
    1、整数的除法:
     
    0做除数抛运行时异常;两整数商会做取整运算,Float或Double与一个整数做除法运算,则商位Float或者Double类型,例如:
     
                    System.out.println( "------------Int相关除法----------"); 
                    System.out.println( "12/10="+12/10); 
                    System.out.println( "12f/10="+12f/10); 
                    System.out.println( "12d/10="+12d/10); 
                    System.out.println( "12/10f="+12/10d); 
                    System.out.println( "12/10d="+12/10f);
     
    ------------Int相关除法---------- 
    12/10=1 
    12f/10=1.2 
    12d/10=1.2 
    12/10f=1.2 
    12/10d=1.2
     
    2、Double(或Float)除法运算:
     
    0可以做除数,得到的是一个分正负的无穷大;当两个数的绝对值均为0.0时候,商等于NaN。当0.0/x,x不等0.0时候,得到的一个带符号位0.0:
     
    package lavasoft.zerotest; 

    /** 
    * 浮点型数据的除法运算测试 

    * @author leizhimin 2009-12-21 9:00:37 
    */
     
    public  class TestZero { 

             public  static  void main(String[] args) { 
                    System.out.println( "------------Double型----------"); 
                    Double x1 = div(2.3, 0.0); 
                    Double x2 = div(2.3, -0.0); 
                    Double x3 = div(0.0, 0.0); 
                    Double x4 = div(0.0, -0.0); 
                    Double x5 = div(0.0, 0.1); 
                    Double x6 = div(0.0, -0.1); 
                     if (x1.isInfinite()) System.out.println( "x1无穷大!"); 
                     if (x2.isInfinite()) System.out.println( "x2无穷大!"); 
                     if (x3.isNaN()) System.out.println( "x3非数字!"); 
                     if (x4.isNaN()) System.out.println( "x4非数字!"); 
                     if (x1 == Double.POSITIVE_INFINITY) System.out.println( "x1 = Double.POSITIVE_INFINITY"); 
                     if (x2 == Double.NEGATIVE_INFINITY) System.out.println( "x1 = Double.NEGATIVE_INFINITY"); 
                     if (x3 == Double.NaN) System.out.println( "x3 = Double.NaN"); 
                     if (x4 == Double.NaN) System.out.println( "x4 = -Double.NaN"); 

                    System.out.println( "------------Float型----------"); 
                    Float y1 = div(2.3f, 0.0f); 
                    Float y2 = div(2.3f, -0.0f); 
                    Float y3 = div(0.0f, 0.0f); 
                    Float y4 = div(0.0f, -0.0f); 
                    Float y5 = div(0.0f, -0.1f); 


                    System.out.println( "------------比较测试----------"); 
                    Float a = 99999999999999999999999999999999999999f; 
                    Float b = 0.000000000000000000000000000000000000000000001f; 
                    Float t = a / b; 
                    System.out.println(t); 
                    System.out.println(Float.MAX_VALUE); 

                     if (t >= Float.MAX_VALUE) { 
                            System.out.println( "a/b的商已经超过了Float的最大值了!"); 
                    } 

            } 

             public  static Double div( double a,  double b) { 
                     double x = a / b; 
                    System.out.println(a +  "/" + b +  " = " + x); 
                     return x; 
            } 

             public  static Float div( float a,  float b) { 
                     float x = a / b; 
                    System.out.println(a +  "/" + b +  " = " + x); 
                     return x; 
            } 

    }
     
    运算输出:
    ------------Double型---------- 
    2.3/0.0 = Infinity 
    2.3/-0.0 = -Infinity 
    0.0/0.0 = NaN 
    0.0/-0.0 = NaN 
    0.0/0.1 = 0.0 
    0.0/-0.1 = -0.0 
    x1无穷大! 
    x2无穷大! 
    x3非数字! 
    x4非数字! 
    x1 = Double.POSITIVE_INFINITY 
    x1 = Double.NEGATIVE_INFINITY 
    ------------Float型---------- 
    2.3/0.0 = Infinity 
    2.3/-0.0 = -Infinity 
    0.0/0.0 = NaN 
    0.0/-0.0 = NaN 
    0.0/-0.1 = -0.0 
    ------------比较测试---------- 
    Infinity 
    3.4028235E38 
    a/b的商已经超过了Float的最大值了! 

    Process finished with exit code 0
     
     
    陷阱:
    零在整数预算中不可以做除数,否则抛运行时异常。
    零在浮点运算中可以做除数,返回值为无穷大。
    NaN各不相同,可看做是Java设计上的一个缺陷。
    浮点型(Float或Double)的除法运算可以接受任何数值,并且结果总是返回一个浮点型的数值。这个数值可能是不合法的,需要进行判断和验证。
     
    3、求余:和除法差不多。
     
                    System.out.println(23%4); 
                    System.out.println(23%-4); 
                    System.out.println(-23%4); 
                    System.out.println(23f%4); 
                    System.out.println(23d%4); 
                    System.out.println(23%4f); 
                    System.out.println(23%4d); 
                    System.out.println(23f%0); 
                    System.out.println(23%0.0); 
                    System.out.println(0.0%0.0);
     
    运行结果:


    -3 
    3.0 
    3.0 
    3.0 
    3.0 
    NaN 
    NaN 
    NaN
     
    陷阱:
    符号位由被除数决定。
     
    对于Double、Float,API都提供了几个有用的判断方法,要注意运用其写出安全的代码:
    boolean isInfinite()    
                        如果该 Double 值的大小是无穷大,则返回  true;否则返回  false。    
    static  boolean isInfinite( double v)    
                        如果指定数字的大小是无穷大,则返回  true;否则,返回  false。    
    boolean isNaN()    
                        如果此 Double 值是非数字(NaN)值,则返回  true;否则,返回  false。    
    static  boolean isNaN( double v)    
                        如果指定的数字是一个非数字 (NaN) 值,则返回  true;否则,返回  false。    
     
    Double、Float类中都提供了一些常量,也可用于判断,当然这些常量也很有意思,看看源码就知道了。
             public  static  final  double POSITIVE_INFINITY = 1.0 / 0.0; 
             public  static  final  double NEGATIVE_INFINITY = -1.0 / 0.0; 
             public  static  final  double NaN = 0.0d / 0.0; 
     

    本文出自 “熔 岩” 博客,请务必保留此出处http://lavasoft.blog.51cto.com/62575/247030

    展开全文
  • java 除法运算 保留小数 number/100

    千次阅读 2019-05-05 23:11:02
    import java.text.DecimalFormat; /** * 数值工具类 */ public class NumberUtil { ... * TODO 除法运算,保留小数 * @param denominator 被除数 分母 * @param numerator 除数 分子 * @return 商 */ ...
    
    import java.text.DecimalFormat;
    
    /**
     * 数值工具类
     */
    public class NumberUtil {
    
        public static void main(String[] args) throws Exception {
            int numerator = 1;//被除数 分子
            int denominator = 100;//除数 分母
            System.out.print(numerator + "/" + denominator + "=");
            System.out.println(toFloat(numerator, denominator));
        }
    
        /**
         * 除法运算,保留小数
         * @param numerator 被除数 分子
         * @param denominator 除数 分母
         * @return 商
         */
        public static Double toFloat(int numerator, int denominator) {
            DecimalFormat df=new DecimalFormat("0.00");//设置保留位数
            return Double.valueOf(df.format((float)numerator/denominator));
        }
    
    }

    展开全文
  • 注意Java除法运算的陷阱

    万次阅读 2013-04-01 12:56:24
    除法运算谁不会啊,很多人不屑一顾,真是无知者无畏! 其实除法、求余运算有一些陷阱。一旦计算发生了问题,还很不好找。不好找的原因主要是问题的偶然性太强,如果你知道可能发生什么问题,你的代码就可以写得更...
    除法运算谁不会啊,很多人不屑一顾,真是无知者无畏! 
    
    其实除法、求余运算有一些陷阱。一旦计算发生了问题,还很不好找。不好找的原因主要是问题的偶然性太强,如果你知道可能发生什么问题,你的代码就可以写得更安全。
    数学除法规定,0不能做除数,因为会得到一个无穷大数据。

    下面看看Java中如何处理这些特殊情况:

    1、整数的除法:
      0做除数抛运行时异常;两整数商会做取整运算,Float或Double与一个整数做除法运算,则商位Float或者Double类型,例如:

       System.out.println("------------Int相关除法----------"); 
      System.out.println("12/10="+12/10); 
      System.out.println("12f/10="+12f/10); 
      System.out.println("12d/10="+12d/10); 
      System.out.println("12/10f="+12/10d); 
      System.out.println("12/10d="+12/10f); 
      ------------Int相关除法---------- 
      12/10=1 
      12f/10=1.2 
      12d/10=1.2 
      12/10f=1.2 
      12/10d=1.2 
    2、Double(或Float)除法运算:
      0可以做除数,得到的是一个分正负的无穷大;当两个数的绝对值均为0.0时候,商等于NaN。当0.0/x,x不等0.0时候,得到的一个带符号位0.0:
    package lavasoft.zerotest; 
      /** 
      * 浮点型数据的除法运算测试 
      * 
      * @author leizhimin 2009-12-21 9:00:37 
      */ 
      public class TestZero { 
      public static void main(String[] args) { 
      System.out.println("------------Double型----------"); 
      Double x1 = div(2.3, 0.0); 
      Double x2 = div(2.3, -0.0); 
      Double x3 = div(0.0, 0.0); 
      Double x4 = div(0.0, -0.0); 
      Double x5 = div(0.0, 0.1); 
      Double x6 = div(0.0, -0.1); 
      if (x1.isInfinite()) System.out.println("x1无穷大!"); 
      if (x2.isInfinite()) System.out.println("x2无穷大!"); 
      if (x3.isNaN()) System.out.println("x3非数字!"); 
      if (x4.isNaN()) System.out.println("x4非数字!"); 
      if (x1 == Double.POSITIVE_INFINITY) System.out.println("x1 = Double.POSITIVE_INFINITY"); 
      if (x2 == Double.NEGATIVE_INFINITY) System.out.println("x1 = Double.NEGATIVE_INFINITY"); 
      if (x3 == Double.NaN) System.out.println("x3 = Double.NaN"); 
      if (x4 == Double.NaN) System.out.println("x4 = -Double.NaN"); 
    
    System.out.println("---Float型---"); 
      Float y1 = div(2.3f, 0.0f); 
      Float y2 = div(2.3f, -0.0f); 
      Float y3 = div(0.0f, 0.0f); 
      Float y4 = div(0.0f, -0.0f); 
      Float y5 = div(0.0f, -0.1f); 
      System.out.println("---比较测试---"); 
      Float a = 99999999999999999999999999999999999999f; 
      Float b = 0.000000000000000000000000000000000000000000001f; 
      Float t = a / b; 
      System.out.println(t); 
      System.out.println(Float.MAX_VALUE); 
      if (t >= Float.MAX_VALUE) { 
      System.out.println("a/b的商已经超过了Float的最大值了!"); 
      } 
      } 
      public static Double div(double a, double b) { 
      double x = a / b; 
      System.out.println(a + "/" + b + " = " + x); 
      return x; 
      } 
      public static Float div(float a, float b) { 
      float x = a / b; 
      System.out.println(a + "/" + b + " = " + x); 
      return x; 
      } 
      } 
    
     运算输出: 
      ----------Double型---------- 
      2.3/0.0 = Infinity 
      2.3/-0.0 = -Infinity 
      0.0/0.0 = NaN 
      0.0/-0.0 = NaN 
      0.0/0.1 = 0.0 
      0.0/-0.1 = -0.0 
      x1无穷大! 
      x2无穷大! 
      x3非数字! 
      x4非数字! 
      x1 = Double.POSITIVE_INFINITY 
      x1 = Double.NEGATIVE_INFINITY 
      ------------Float型---------- 
      2.3/0.0 = Infinity 
      2.3/-0.0 = -Infinity 
      0.0/0.0 = NaN 
      0.0/-0.0 = NaN 
      0.0/-0.1 = -0.0 
      ------------比较测试---------- 
      Infinity 
      3.4028235E38 
      a/b的商已经超过了Float的最大值了! 
      Process finished with exit code 0 
    陷阱:
      零在整数预算中不可以做除数,否则抛运行时异常。
      零在浮点运算中可以做除数,返回值为无穷大。
      NaN各不相同,可看做是Java设计上的一个缺陷。
      浮点型(Float或Double)的除法运算可以接受任何数值,并且结果总是返回一个浮点型的数值。这个数值可能是不合法的,需要进行判断和验证。 

    3、求余:和除法差不多。
            

       System.out.println(23%4); 
      System.out.println(23%-4); 
      System.out.println(-23%4); 
      System.out.println(23f%4); 
      System.out.println(23d%4); 
      System.out.println(23%4f); 
      System.out.println(23%4d); 
      System.out.println(23f%0); 
      System.out.println(23%0.0); 
      System.out.println(0.0%0.0); 
      运行结果: 
      3 
      3 
      -3 
      3.0 
      3.0 
      3.0 
       3.0 
      NaN 
      NaN 
      NaN 
    陷阱:
      符号位由被除数决定。
      对于Double、Float,API都提供了几个有用的判断方法,要注意运用其写出安全的代码:
      boolean isInfinite()
      如果该 Double 值的大小是无穷大,则返回 true;否则返回 false。
      static boolean isInfinite(double v)
      如果指定数字的大小是无穷大,则返回 true;否则,返回 false。
      boolean isNaN()
      如果此 Double 值是非数字(NaN)值,则返回 true;否则,返回 false。
      static boolean isNaN(double v)
      如果指定的数字是一个非数字 (NaN) 值,则返回 true;否则,返回 false。
      Double、Float类中都提供了一些常量,也可用于判断,当然这些常量也很有意思,看看源码就知道了。
      
       public static final double POSITIVE_INFINITY = 1.0 / 0.0; 
      public static final double NEGATIVE_INFINITY = -1.0 / 0.0; 
      public static final double NaN = 0.0d / 0.0; 

      原文地址:http://lavasoft.blog.51cto.com/62575/247030

    展开全文
  • i 知识点: “/” 除以取整 ,“%”除以取余 , 但是 “/” 被数如果是浮点型数值 获取到的值可以是浮点型精确值 关注代码片段: sum 为 int 类型:average=sum/nums.length; sum 为 浮点型数值:average=(double...
  •  根据提供的毫秒数进行除法运算,如果将毫秒数转换成小时,小时数不为0,则只取整数位,依此类推... 2.情况分析  可以使用3个函数实现  Math.floor(num) 只保留整数位  Math.rint(num) 余数四舍五入  ...
  • Java除法运算(保留几位小数)

    千次阅读 2018-12-27 20:55:51
    DecimalFormat df = new DecimalFormat("0.00");//设置保留位数 return df.format(运算);
  • 示例如下:float num= (float)2/3;DecimalFormat df = new DecimalFormat("0.00");//格式化小数String s = df.format(num);//返回的是String类型,如果没有强转为float或者double,那么int型的2除以3,结果...
  • java除法 java运算符 java运算特殊情况

    千次阅读 2018-07-16 14:32:40
    java除法运算的特殊情况: System.out.println(5/2); System.out.println(5.0/2); System.out.println(5/2.0); System.out.println(5.0/0); System.out.println(-5.0/0); System.out.println(0.0/0);...
  • 但是要求程序对除法运算过程中的各种异常进行捕捉并提示用户,例如除数是字符、被除数是零等。 在这个实例中定义了一个数组来存放要执行运算的两个操作数,因此还需要对数组的索引越界异常进行处理,具体步骤如下。 ...
  • 使用Java处理除法运算的陷阱

    千次阅读 2014-11-20 16:18:41
    除法运算谁不会啊,很多人不屑一顾,其实除法、求余运算有一些陷阱。一旦计算发生了问题,还很不好找。不好找的原因主要是问题的偶然性太强,如果你知道可能发生什么问题,你的代码就可以写得更安全。  数学除法...
  • java异常除法运算的处理

    千次阅读 2018-07-31 14:55:05
    import java.util.Scanner; public class Test1 { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.println(“请输入被数”); int num1 = in.nextInt(); try{ ...
  • java精确除法运算(BigDecimal)

    千次阅读 2019-08-12 10:01:28
    Java中提供了大数字(超过16位有效位)的操作类,即 java.math.BinInteger 类和 java.math.BigDecimal 类,用于高精度计算.  其中 BigInteger 类是针对大整数的处理类,而 BigDecimal 类则是针对大小数的处理类.  ...
  • java中的除法运算

    千次阅读 2010-06-05 16:09:01
    小心除法运算   不同类型的数进行除法运算 long a = 123124323;   long b = 123124343;   (b-a)/1000000 -----> 0   int a = 4; int b = 3; (a/b) = 1 (b/a)=0   数据格式处理  ...
  • 借用我们小学阶段计算整数除法的思路(看下面代码前,建议先在草稿纸上按照小学做除法运算的步骤做一次二进制除法运算)。 扫描下方二维码,及时获取更多互联网求职面经、java、python、爬虫、大数据等技术,和...
  • 蓝桥试题 算法训练 除法运算 JAVA

    千次阅读 2020-04-30 20:28:34
     输入两个整数,判断第一个数能否被第二个数整除(即第一个数第二个数能否除尽),如果能够除尽,输出1,否则输出0. 输入格式  输入两个整数,第一个数表示被数,第二个数表示除数。 输出格式  输出是否能...
  • BigDecimal 除法运算出现 java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result 的解决办法  今天在使用两个BigDecimal类型的数字做除法运算时,出现了一个...
  • 使用DecimalFormat 对运算结果按照指定格式输出。 具体代码如下所示: package com.data; import java.text.DecimalFormat; public class TestLong01 { public static void main(String[] args) { ...
  • JAVA中的除法运算

    千次阅读 2009-11-16 16:53:00
    inta=4;intb=3;floatc=(float)a/b;System.out.print(c);//输出:1如果要的到精确的结果,要用下面的方法inta=4;intb=3;floatc=(float)a/(float)b;System.out.print(c);//输出:1.3333334 转载于:...
  • DecimalFormat df = new DecimalFormat("0.00");//设置保留位数 return df.format(运算);
  • 我们知道,相比移位运算,除法运算的开销比较大。 在 Leetcode 做题的时候,当除数是 2的 n 次幂时,大家通常会用移位来代替除法运算,并且希望这样能够提升运算效率——这似乎已成为了算法题解中的“标配”。 那么...
  • JAVA中int类除法运算保留2位

    千次阅读 2017-11-04 15:05:02
    //导DecimalFormat包  ...import java.text.DecimalFormat; public class Demo1 { public static void main(String[] args) throws Exception{ DecimalFormat df = new DecimalFormat("0.00"); 
  • java.lang.ArithmeticException: Non-terminating decimal ...项目中计算两个较大数除法时,无法整除,出现无限循环小数时,抛出异常. 解决方法: BigDecimal.ROUND_HALF_UP设置除法的四舍五入 BigDecimal b1 = ne...
  • 今天在使用两个BigDecimal类型的数字做除法运算时,出现了一个如下的异常信息: 1 java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result  上网查了一下这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,949
精华内容 24,779
关键字:

java除法运算

java 订阅