数字格式化

数字格式化是用模板控制内容数字类型，用到DecimalFormat类进行格式化

DecimalFormat类有特殊字符构成的格式化模板，是数字会按照特殊字符规则进行匹配

DecimalFormat类中特殊字符的说明

字符	说明
0	一个数字，不存在则显示0
#	一个数字，存在则显示，否则不显示
.	小数分隔符或货币小数分隔符
-	符号
,	分组分隔符
E	分隔科学计数法中的尾数和指数
%	存在数字的前缀或后缀，乘100显示百分数
\u2030	存在数字的前缀或后缀，乘1000显示千分数
\u00A4	存在数字的前缀或后缀，显示货币记号
‘	视为普通单引号处理

DecimalFormat类方法

DecimalFormat.applyPattern（String patten）设置数字格式化模板

DecimalFormat.format（value）转换模板样式

import java.text.DecimalFormat;
//有DecimalFormat包的调用

static public void Sformat(String patten, double value){
    
    
        //pattem：模板，value：数值
        //实例化对象
        DecimalFormat n = new DecimalFormat(patten);
        //进行格式化的方法 format(double value)
        String out = n.format(value);
        System.out.println("模板："+patten+"，数值 "+value+"\n结果："+out);
        System.out.println();
    }
    static public void Sformat2(String patten, double value){
    
    
        //pattem：模板，value：数值
        //实例化对象
        DecimalFormat n = new DecimalFormat(patten);
        //设置格式化模板
        n.applyPattern(patten);
        System.out.println("模板："+patten+"，数值 "+value+"\n结果："+n.format(value));
        System.out.println();
    }
    
    public static void main(String[] args) {
    
    
        //静态调用方法，无需实例化
        Sformat("###,###,###",12345.6789);
        Sformat("00000000.###kg",12345.6789);
        Sformat("000000.000",123.45);
        System.out.println("------------");
        Sformat2("#.###%",0.789);
        Sformat2("###.##",123456.789);
        Sformat2("0.00\u2030",0.789);
    }

运行结果

模板：###,###,###，数值 12345.6789
结果：12,346

模板：00000000.###kg，数值 12345.6789
结果：00012345.679kg

模板：000000.000，数值 123.45
结果：000123.450

------------
模板：#.###%，数值 0.789
结果：78.9%

模板：###.##，数值 123456.789
结果：123456.79

模板：0.00‰，数值 0.789
结果：789.00‰

数字运算

Math类

Math类提供了数学函数方法

不用调用包

都是静态方法

常用数学运算方法

三角函数方法

Math.sin（double a）返回三角正弦

Math.cos（double a）返回三角余弦

Math.tan（double a）返回三角正切

Math.asin（double a）返回一个反正弦

Math.acos（double a）返回一个反余弦

Math.atan（double a）返回一个反正切

Math.toRadians（double a）角度转换为弧度

Math.toDegrees（double a）弧度转换为角度

public static void main(String[] args) {
    
    
        System.out.println("PI："+Math.PI);
        
        System.out.println("Math.sin（double a） 返回三角正弦(90)："+Math.sin(Math.PI/2));
        
        System.out.println("Math.cos（double a） 返回三角余弦："+Math.cos(0));
        
        System.out.println("Math.tan（double a） 返回三角正切："+Math.tan(Math.PI/3));
        //取2点平方根与2商的反正弦
        System.out.println("Math.asin（double a） 返回一个反正弦："+Math.asin(Math.sqrt(2)/2));
        //取2点平方根与2商的反余弦
        System.out.println("Math.acos（double a） 返回一个反余弦："+Math.acos(Math.sqrt(2)/2));
        
        System.out.println("Math.atan（double a） 返回一个反正切："+Math.atan(1));
        
        System.out.println("Math.toRadians（double a） 角度转换为弧度："+Math.toRadians(120.0));
        
        System.out.println("Math.toDegrees（double a） 弧度转换为角度："+Math.toDegrees(Math.PI/2));
}

运行结果

PI：3.141592653589793
Math.sin（double a） 返回三角正弦(90)：1.0
Math.cos（double a） 返回三角余弦：1.0
Math.tan（double a） 返回三角正切：1.7320508075688767
Math.asin（double a） 返回一个反正弦：0.7853981633974484
Math.acos（double a） 返回一个反余弦：0.7853981633974483
Math.atan（double a） 返回一个反正切：0.7853981633974483
Math.toRadians（double a） 角度转换为弧度：2.0943951023931953
Math.toDegrees（double a） 弧度转换为角度：90.0

指数函数方法

Math.exp（double a）获取e的a次方

Math.log（double a）取自然对数，即取lna的值

Math.log10（double a）取底数为10的对数

Math.sqrt（double a）取a的平方根，a不能为负数

Math.cbrt（double a）取a的立方根

Math.pow（double a,double b）取a的b次方

public static void main(String[] args) {
    
    
    System.out.println("Math.exp（double a）  获取e的a次方："+Math.exp(2));
    
    System.out.println("Math.log（double a）  取自然对数，即取lna的值："+Math.log(2));
    
    System.out.println("Math.log10（double a）取底数为10的对数："+Math.log10(2));
 
    System.out.println("Math.sqrt（double a）  取a的平方根，a不能为负数："+Math.sqrt(2));
    
    System.out.println("Math.cbrt（double a）  取a的立方根："+Math.cbrt(2));
    
    System.out.println("Math.pow（double a）  取a的b次方："+Math.pow(2,3));
}

运行结果

Math.exp（double a）  获取e的a次方：7.38905609893065
Math.log（double a）  取自然对数，即取lna的值：0.6931471805599453
Math.log10（double a）取底数为10的对数：0.3010299956639812
Math.sqrt（double a）  取a的平方根，a不能为负数：1.4142135623730951
Math.cbrt（double a）  取a的立方根：1.2599210498948732
Math.pow（double a）  取a的b次方：8.0

取整函数方法

Math.ceil（double a）返回大于等于参数的最小整数

Math.floor（double a）返回小于等于参数的最大整数

Math.rint（double a）返回与参数接近的整数，如果两整数一样，则取偶数

Math.round（float a）返回参数加 0.5 后与参数接近的整数

Math.round（double a）返回参数加 0.5 后与参数接近的整数并转换为长整型(double)

public static void main(String[] args) {
    
    
    System.out.println("Math.ceil（double a） 返回大于等于参数的最小整数："+Math.ceil(5.2));
    
    System.out.println("Math.floor（double a）返回小于等于参数的最大整数："+Math.floor(2.5));
    
    System.out.println("Math.rint（double a） 返回与参数接近的整数，如果两整数一样，则取偶数："+Math.rint(2.7));
    
    System.out.println("Math.round（float a） 返回参数加 0.5 后与参数接近的整数："+Math.round(3.4f));
    
    System.out.println("Math.round（double a） 返回参数加 0.5 后与参数接近的整数并转换为长整型(double)："+Math.round(2.5));
}

运行结果

Math.ceil（double a） 返回大于等于参数的最小整数：6.0
Math.floor（double a）返回小于等于参数的最大整数：2.0
Math.rint（double a） 返回与参数接近的整数，如果两整数一样，则取偶数：3.0
Math.round（float a） 返回参数加 0.5 后与参数接近的整数：3
Math.round（double a） 返回参数加 0.5 后与参数接近的整数并转换为长整型(double)：3

最大、最小、绝对值函数方法

Math.max（double a ，double b）取a ，b 较大值，参数整型

Math.min（int a ，int b）取a ，b 较小值，参数整型

Math.min（long a ，long b）取a ，b 较小值，参数长整型

Math.min（float a ，float b）取a ，b 较小值，参数浮点型

Math.min（doubl a ，double b）取a ，b 较小值，参数双精度型

Math.abs（int a）返回整型参数的绝对值

Math.abs（long a）返回长整型参数的绝对值

Math.abs（float a）返回浮点型参数的绝对值

Math.abs（double a）返回双精度型参数的绝对值

public static void main(String[] args) {
    
    
    System.out.println("Math.max（double a ，double b） 取a ，b 较大值，参数整型："+Math.max(4.3,4.2));
    
    System.out.println("Math.min（int a ，int b） 取a ，b 较小值，参数整型："+Math.min(3,4));
    
    System.out.println("Math.abs（double a） 返回双精度型参数的绝对值："+Math.abs(-5.3));
}

运行结果

Math.max（double a ，double b） 取a ，b 较大值，参数整型：4.3
Math.min（int a ，int b） 取a ，b 较小值，参数整型：3
Math.abs（double a） 返回双精度型参数的绝对值：5.3

随机数

Math.random（）方法

Math类中的random（）方法，用于产生随机数字，该方法默认生成 0 ~ 1 之间的double型随机数

以下方法可以从0 控制的范围
$M a t h . r a n d o m () * m$

$0 * m < = d o u b l e 值 * m < 1 * m$

$0 < = d o u b l e 值 < m$

public static void main(String[] args) {
    
    
    System.out.println("1 - 100 的随机数："+(int)(Math.random()*100));
    
    System.out.println("50 - 100 的随机数："+(int)(50+Math.random()*(100-50)));
    //'a'+Math.random()*('z'-'a'+1) ：后面加1原因因为要包含字母‘z’
    System.out.println("a - z 的随机字符："+(char)('a'+Math.random()*('z'-'a'+1)));
}

运行结果

1 - 100 的随机数：84
50 - 100 的随机数：64
a - z 的随机字符：s

Random类

Java提供有Java.util.Random类，可以通过Random对象创建随机数生成器

Random r = new Random(seedValue);

seedValue：系统时间作为随机数生成的种子

Random方法

Random.nextInt（）返回随机整数

Random.nextInt（int n）返回大于等于0且小于n的随机数

Random.nextLong（）返回随机数长整型

Random.nextBoolean（）返回随机数布尔值

Random.nextFloat（）返回随机数浮点型

Random.nextDouble（）返回随机数双精度型

Random.nextGaussian（）返回概率密度为高斯分布的双精度值

public static void main(String[] args) {
    
    
    Random d = new Random();
    
    System.out.println("nextInt（） 返回随机整数："+d.nextInt());
    
    System.out.println("nextInt（int n） 返回大于等于0且小于n的随机数(10)："+d.nextInt(10));
    
    System.out.println("nextLong（） 返回随机数长整型："+d.nextLong());
    
    System.out.println("nextBoolean（）返回随机数布尔值："+d.nextBoolean());
    
    System.out.println("nextFloat（） 返回随机数浮点型："+d.nextFloat());
    
    System.out.println("nextDouble（） 返回随机数双精度型："+d.nextDouble());
    
    System.out.println("nextGaussian（） 返回概率密度为高斯分布的双精度值："+d.nextDouble());
}

运行结果

nextInt（） 返回随机整数：1697026804
nextInt（int n） 返回大于等于0且小于n的随机数(10)：3
nextLong（） 返回随机数长整型：-2264169696298848856
nextBoolean（）返回随机数布尔值：false
nextFloat（） 返回随机数浮点型：0.7777471
nextDouble（） 返回随机数双精度型：0.10485108224186857
nextGaussian（） 返回概率密度为高斯分布的双精度值：0.22713289568100314

大数字运算

BigInteger

java.math.BigInteger类可以准确地表示任何大小的整型而不会丢失数据

new BigInteger（String val）; （val：是十进制字符串）
BigInteger.valueOf(Long);

以上有两种方式获取 BigInteger对象

BigInteger方法

BigInteger.add（BigInteger val）加法运算

BigInteger.subtract（BigInteger val）减法运算

BigInteger.mulitply（BigInteger val）乘法运算

BigInteger.divide（BigInteger val）除法运算

BigInteger.remainder（BigInteger val）取余操作

BigInteger.divideAndRemainder（BigInteger val）用数组返回余数的商，结果：第一个为商，第二个为余数

BigInteger.pow（int n）取参数 n次方的操作

BigInteger.negate（）取相反数

BigInteger.shiftLeft（int n）将数字左移n位，负数则右移

BigInteger.shiftRight（int n）将数字右移n位，负数则左移

BigInteger.and（BigInteger val）与操作

BigInteger.or（BigInteger val）或操作

BigInteger.compareTo（BigInteger val）数字比较

BigInteger.equals（Object x）判断内容是否相同

BigInteger.min（BigInteger val）返回较小值

BigInteger.max（BigInteger val）返回较大值

BigInteger.gcd（BigInteger val）返回最大公约数

public static void main(String[] args) {
    
    
    BigInteger b = new BigInteger("999");
    BigInteger b2 = BigInteger.valueOf(99999);
    
    System.out.println("BigInteger.add（BigInteger val） 加法运算："+b.add(new BigInteger("1")));
    
    System.out.println("BigInteger.subtract（BigInteger val） 减法运算："+b.subtract(new BigInteger("1")));
    
    System.out.println("BigInteger.mulitply（BigInteger val）乘法运算："+b.multiply(new BigInteger("2")));
    
    System.out.println("BigInteger.divide（BigInteger val）除法运算："+b.divide(new BigInteger("3")));
    
    System.out.println("BigInteger.remainder（BigInteger val）取余操作："+b.remainder(new BigInteger("5")));
    
    System.out.print("BigInteger.divideAndRemainder（BigInteger val）用数组返回余数的商，结果：第一个为商，第二个为余数：");
    BigInteger[] big = b.divideAndRemainder(new BigInteger("5"));
    for (BigInteger tmp : big){
    
    
        System.out.print(tmp+"\t");}
    System.out.println();
    
    System.out.println("BigInteger.pow（int n）取参数 n次方 的操作："+b.pow(2));
    
    System.out.println("BigInteger.negate（）取相反数："+b.negate());
    
    System.out.println("BigInteger.shiftLeft（int n）将数字左移n位，负数则右移2："+b.shiftLeft(2));
    System.out.println("BigInteger.shiftLeft（int n）将数字左移n位，负数则右移-2："+b.shiftLeft(-2));
    
    System.out.println("BigInteger.shiftRight（int n）将数字右移n位，负数则左移2："+b.shiftRight(2));
    System.out.println("BigInteger.shiftRight（int n）将数字右移n位，负数则左移-2："+b.shiftRight(-2));
    
    System.out.print("BigInteger.and（BigInteger val）与 操作：");
    if (b.equals(b.and(new BigInteger("999")))){
    
    
        System.out.println("yes");
    }else {
    
    
        System.out.println("no"); }
    
    System.out.print("BigInteger.or（BigInteger val）或 操作：");
    if (b2.equals(b.or(new BigInteger("99999")))){
    
    
        System.out.println("yes");
    }else {
    
    
        System.out.println("no"); }
    
    System.out.println("BigInteger.compareTo（BigInteger val）数字比较999："+b.compareTo(new BigInteger("999")));
    System.out.println("BigInteger.compareTo（BigInteger val）数字比较99："+b.compareTo(new BigInteger("99")));
    
    System.out.println("BigInteger.equals（Object x）判断内容是否相同："+b.equals(b2));
    
    System.out.println("BigInteger.min（BigInteger val）返回较小值："+b.min(b2));
    
    System.out.println("BigInteger.max（BigInteger val）返回较大值："+b.max(b2));
    
    //new BigInteger("a").gcd(new BigInteger("b"));    a 与 b 的最大公约数！！！
    System.out.println("BigInteger.gcd（BigInteger val）返回最大公约数："+new BigInteger("23123213").gcd(new BigInteger("2443512")));
}

运行结果

BigInteger.add（BigInteger val） 加法运算：1000
BigInteger.subtract（BigInteger val） 减法运算：998
BigInteger.mulitply（BigInteger val）乘法运算：1998
BigInteger.divide（BigInteger val）除法运算：333
BigInteger.remainder（BigInteger val）取余操作：4
BigInteger.divideAndRemainder（BigInteger val）用数组返回余数的商，结果：第一个为商，第二个为余数：199	4
BigInteger.pow（int n）取参数 n次方 的操作：998001
BigInteger.negate（）取相反数：-999
BigInteger.shiftLeft（int n）将数字左移n位，负数则右移2：3996
BigInteger.shiftLeft（int n）将数字左移n位，负数则右移-2：249
BigInteger.shiftRight（int n）将数字右移n位，负数则左移2：249
BigInteger.shiftRight（int n）将数字右移n位，负数则左移-2：3996
BigInteger.and（BigInteger val）与 操作：yes
BigInteger.or（BigInteger val）或 操作：no
BigInteger.compareTo（BigInteger val）数字比较999：0
BigInteger.compareTo（BigInteger val）数字比较99：1
BigInteger.equals（Object x）判断内容是否相同：false
BigInteger.min（BigInteger val）返回较小值：999
BigInteger.max（BigInteger val）返回较大值：99999
BigInteger.gcd（BigInteger val）返回最大公约数：17

BigDecimal

java.math.BigDecimal类可以高精度浮动运算，支持任何精度的定点数

BigDecimal构造方法

new BigDecimal（String val）
new BigDecima（double val）
BigDecima.valueOf（double val）

以上有三种方式获取 BigDecimal对象

BigDecimal方法

BigDecimal.add（BigDecimal val）加法运算

BigDecimal.subtract（BigDecimal val）减法运算

BigDecimal.multiply（BigDecimal val）乘法运算

BigDecimal.divide（BigDecimal val）除法运算

BigDecimal.divide（BigDecimal val , int n , int j）除法运算

val：除数
i：小数位数
j：近似值处理模式

处理模式	说明	定义值
BigDecimal.ROUND_UP	商最后一位大0，进位，正负一样	0
BigDecimal.ROUND_DOWN	商最后一位直接省略	1
BigDecimal.ROUND_CEILING	商正数0处理，负数则1处理	2
BigDecimal.ROUND_FLOOR	商正数1处理，负数则0处理	3
BigDecimal.ROUND_HALF_UP	商最后一位，四舍五入，大于等于5进位，小于5省略	4
BigDecimal.ROUND_HALF_DOWN	商最后一位，四舍五入，大于5进位，小于等于5省略	5
BigDecimal.ROUND_HALF_EVEN	商的倒数第二位，奇数4处理，偶数5处理	6

public static void main(String[] args) {
    
    
        BigDecimal b1 = new BigDecimal("30.12");
        BigDecimal b2 = new BigDecimal(40.12);
        BigDecimal b3 = BigDecimal.valueOf(50.12);
        
        
        System.out.println("BigDecimal.add（BigDecimal val） 加法运算："+b1.add(b2));
        
        System.out.println("BigDecimal.subtract（BigDecimal val） 减法运算："+b1.subtract(b2));
        
        System.out.println("BigDecimal.multiply（BigDecimal val） 乘法运算："+b1.multiply(b2));
    
        BigDecimal d = new BigDecimal(5);
        System.out.println("BigDecimal.divide（BigDecimal val） 除法运算："+b3.divide(d));
        
        System.out.println("BigDecimal.divide（BigDecimal val , int n , int j） 除法运算：");
        // 0 ：ROUND_UP
        // 1 ：ROUND_DOWN
        // 2 ：ROUND_CEILING
        // 3 ：ROUND_FLOOR
        // 4 ：ROUND_HALF_UP
        // 5 ：ROUND_HALF_DOWN
        // 6 ：ROUND_HALF_EVEN
        System.out.println("50.12/3 = " + b3.divide(new BigDecimal("3"), 20,0));
        System.out.println("（0）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,0));
        System.out.println("（1）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,1));
        System.out.println("（2）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,2));
        System.out.println("（3）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,3));
        System.out.println("（4）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,4));
        System.out.println("（5）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,5));
        System.out.println("（6）50.12/3 = " + b3.divide(new BigDecimal("3"), 18,6));
    }

运行结果

BigDecimal.add（BigDecimal val） 加法运算：70.23999999999999744204615126363933086395263671875
BigDecimal.subtract（BigDecimal val） 减法运算：-9.99999999999999744204615126363933086395263671875
BigDecimal.multiply（BigDecimal val） 乘法运算：1208.4143999999999229544300760608166456222534179687500
BigDecimal.divide（BigDecimal val） 除法运算：10.024
BigDecimal.divide（BigDecimal val , int n , int j） 除法运算：
50.12/3 = 16.70666666666666666667
（0）50.12/3 = 16.706666666666666667
（1）50.12/3 = 16.706666666666666666
（2）50.12/3 = 16.706666666666666667
（3）50.12/3 = 16.706666666666666666
（4）50.12/3 = 16.706666666666666667
（5）50.12/3 = 16.706666666666666667
（6）50.12/3 = 16.706666666666666667

Java学习记录数字处理篇

数字格式化

数字运算

三角函数方法

指数函数方法

取整函数方法

最大、最小、绝对值函数方法

随机数

Math.random（）方法

Random类

大数字运算

BigInteger

BigInteger方法

BigDecimal

猜你喜欢

Java学习记录 数字处理篇

数字格式化

数字运算

三角函数方法

指数函数方法

取整函数方法

最大、最小、绝对值函数方法

随机数

Math.random（）方法

Random类

大数字运算

BigInteger

BigInteger方法

BigDecimal

猜你喜欢

Java学习记录数字处理篇