欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

【Java学习日记】#13数字处理类 数字格式化 DecimalFormat类 格式化模板 数字运算 Math类 随机数 大数字运算

程序员文章站 2022-07-03 14:50:23
数字处理类数字格式化DecimalFormat类（十进制数字格式化类）构造方法格式化模板使用数字运算Math类常数值常用数学运算方法数字格式化Java中没有格式化的数据遵循以下原则：如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。如果数据绝对值小于0.001或者大于10000000，使用科学计数法表示。DecimalFormat类（十进制数字格式化类）DecimalFormat是NumberFormat的一个子类，用于格式化十进制数字。它可以将一些数字格式化位...

数字处理类

数字格式化

Java中没有格式化的数据遵循以下原则：

  • 如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。
  • 如果数据绝对值小于0.001或者大于10000000，使用科学计数法表示。

DecimalFormat类（十进制数字格式化类）

DecimalFormat是NumberFormat的一个子类，用于格式化十进制数字。它可以将一些数字格式化位整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。

构造方法

  1. 利用字符串参数（格式化模板）
    DecimalFormat df = new DecimalFormat("####");
    ####：格式化模板
  2. 使用空的构造方法后调用此对象的applyPattern()
DecimalFormat df = new DecimalFormat();
df.applyPattern("####");

格式化模板

字符 说明
0 数字占位符，如果该位不存在数字，则显示0
# 数字占位符。如果该位不存在数字，则不显示
. 小数点分隔符
, 分组分隔符
’ 转义字符
% 百分号%，将数字乘以100显示为百分数
\u2030 千分号‰，将数字乘以1000显示为千分数

使用

import java.text.DecimalFormat;

public class DecimalFormatUse {
    static void format(String pattern, double value){
        DecimalFormat df = new DecimalFormat(pattern);
        System.out.println("数值："+value);
        System.out.println("格式化模板："+pattern);
        System.out.println("格式化之后："+df.format(value));
        System.out.println();

    }
    public static void main(String[] args) {
        format("000",123);
        format("0000",123);
        format("####",123);
        format("##,##",123456.7891245);//自动进位
        format("##,##.##",123456.7891245);//带上小数点
        format("###,###.###",123456.7891245);
        format("###,###.###$",123456.7891245);//金额
    }
}

数值：123.0
格式化模板：000
格式化之后：123

数值：123.0
格式化模板：0000
格式化之后：0123

数值：123.0
格式化模板：####
格式化之后：123

数值：123456.7891245
格式化模板：##,##
格式化之后：12,34,57

数值：123456.7891245
格式化模板：##,##.##
格式化之后：12,34,56.79

数值：123456.7891245
格式化模板：###,###.###
格式化之后：123,456.789

数值：123456.7891245
格式化模板：###,###.###$
格式化之后：123,456.789$

小数点后表示小数点后保留几位，所以不能再加逗号

format("##,##.##,##",123456.7891245);

上述代码会报错

千分号：

import java.text.DecimalFormat;

public class DecimalFormatUse {
    static void format(String pattern, double value){
        DecimalFormat df = new DecimalFormat(pattern);
        System.out.println("数值："+value);
        System.out.println("格式化模板："+pattern);
        System.out.println("格式化之后："+df.format(value));
        System.out.println();

    }
    public static void main(String[] args) {
        format("\u2030",0.0256);
        format("0.000\u2030",0.0256);//千分号放到后面
    }
}

数值：0.0256
格式化模板：‰
格式化之后：‰26

数值：0.0256
格式化模板：0.000‰
格式化之后：25.600‰

数字运算

Java语言中提供了一个执行数学基本运算的Math类，该类包括常用的数学运算方法，如三角函数方法、指数函数方法、对数函数方法、平方根函数方法等一些常用数学函数。除此之外还提供了一些常用的数学常量，如PI、E等。

Math类

Math类位于Java的lang包下。

java.lang包不需要引入，系统会自动调用。
Math提供的都是静态方法。可以通过Math.的方式直接调用这些方法。

常数值

public class MathUse {
    public static void main(String[] args) {
        System.out.println("圆周率的值："+Math.PI);
        System.out.println("e的值："+Math.E);
    }
}

圆周率的值：3.141592653589793
e的值：2.718281828459045

常用数学运算方法

三角函数方法
public class MathUse {
    public static void main(String[] args) {
        System.out.println("PI/4的正弦："+Math.sin(Math.PI/4));
        System.out.println("PI/4的余弦："+Math.cos(Math.PI/4));
        System.out.println("PI/4的正切："+Math.tan(Math.PI/4));
        System.out.println("PI/4的反正弦："+Math.asin(Math.PI/4));
        System.out.println("PI/4的反余弦："+Math.acos(Math.PI/4));
        System.out.println("PI/4的反正切："+Math.atan(Math.PI/4));
        System.out.println("45度角度转换为弧度："+Math.toRadians(45));
        System.out.println("PI/4弧度转换为角度："+Math.toDegrees(Math.PI/4));
    }
}

PI/4的正弦：0.7071067811865475
PI/4的余弦：0.7071067811865476
PI/4的正切：0.9999999999999999
PI/4的反正弦：0.9033391107665127
PI/4的反余弦：0.6674572160283838
PI/4的反正切：0.6657737500283538
45度角度转换为弧度：0.7853981633974483
PI/4弧度转换为角度：45.0

指数函数方法
public class MathUseIndex {
    public static void main(String[] args) {
        double a = 2;
        double b = 2;
        System.out.println("e的a次方："+Math.exp(a));
        System.out.println("lna："+Math.log(a));
        System.out.println("lga："+Math.log10(a));
        System.out.println("a^(1/2)："+Math.sqrt(a));
        System.out.println("a^(1/3)："+Math.cbrt(a));
        System.out.println("a的b次方："+Math.pow(a,b));
    }
}

e的a次方：7.38905609893065
lna：0.6931471805599453
lga：0.3010299956639812
a^(1/2)：1.4142135623730951
a^(1/3)：1.2599210498948732
a的b次方：4.0

取整函数方法
public class MathIntUse {
    public static void main(String[] args) {
        double a = 2.33;
        System.out.println("大于等于a的最小整数："+Math.ceil(a));
        System.out.println("小于等于a的最大整数："+Math.floor(a));
        System.out.println("与a最接近的整数（有两个数则结果为偶数）："+Math.rint(a));
        System.out.println("加上0.5后与a最接近的整数："+Math.round((float)a));
        System.out.println("加上0.5后与a最接近的整数（强制返回长整型）："+Math.round(a));
    }
}

大于等于a的最小整数：3.0
小于等于a的最大整数：2.0
与a最接近的整数（有两个数则结果为偶数）：2.0
加上0.5后与a最接近的整数：2
加上0.5后与a最接近的整数（强制返回长整型）：2

取最大值、最小值、绝对值
public class MathMaxMinUse {
    public static void main(String[] args) {
        double a = -2;
        double b = -4;
        System.out.println("a与b之间的最大值："+Math.max(a,b));
        System.out.println("a与b之间的最小值："+Math.min(a,b));
        System.out.println("a与b之间的最小值（参数长整型）："+Math.max((long)a,(long)b));
        System.out.println("a与b之间的最小值（参数浮点型）："+Math.max((float)a,(float)b));
        System.out.println("a与b之间的最小值（整型）："+Math.max((int)a,(int)b));
        System.out.println("a的绝对值："+Math.abs(a));
        System.out.println("a的绝对值（整型）："+Math.abs((int)a));
        System.out.println("a的绝对值（长整型）："+Math.abs((long)a));
        System.out.println("a的绝对值（浮点型）："+Math.abs((float)a));
    }
}

a与b之间的最大值：-2.0
a与b之间的最小值：-4.0
a与b之间的最小值（参数长整型）：-2
a与b之间的最小值（参数浮点型）：-2.0
a与b之间的最小值（整型）：-2
a的绝对值：2.0
a的绝对值（整型）：2
a的绝对值（长整型）：2
a的绝对值（浮点型）：2.0

随机数

Math.random()方法

该方法默认生成大于等于0.0且小于1.0的double随机数。
即 0<=Math.random()<1.0

生成五个0-10之间的整数

public class MathRandomUse {
    public static void main(String[] args) {
        for (int i=1;i<=5;i++){
            System.out.println((int)(Math.random()*10));
        }
    }
}

每次输出结果都不一样

获取m~m+n之间的随机数：

m+(int)(Math.random()*n)

获取2-5之间的整数：

public class MathRandomUse {
    public static void main(String[] args) {
        double m=2;
        double n=4;
        for (int i=1;i<=5;i++){
            System.out.println((int)(m+(int)(Math.random()*n)));
        }
    }
}

获取m~n之间的随机数：

m+(int)(Math.random()*(n-m))

获取2-32之间的整数：

public class MathRandomUse {
    public static void main(String[] args) {
        double m=2;
        double n=32;
        for (int i=1;i<=5;i++){
            System.out.println((int)(m+(int)(Math.random()*(n-m))));
        }
    }
}

获取'a'~'z'之间的字符：

public class MathRandomUse {
    public static void main(String[] args) {
        char m='a';
        char n='z';
        for (int i=1;i<=5;i++){
            System.out.println((char) (m+(int)(Math.random()*(n-m))));
        }
    }
}

Random类

除了Math类中的random方法可以获取随机数之外，Java中还提供了一种可以获取随机数的方式——java.util.Random类。

Random r = new Random(seedValue);

r：Random类对象
seedValue：随机数生成器种子

import java.util.Random;

public class RandomClass {
    public static void main(String[] args) {
        int n=10;
        Random r = new Random();
        System.out.println("随机产生一个整数："+r.nextInt());
        System.out.println("随机产生一个大于等于0且小于n的整数："+r.nextInt(n));
        System.out.println("随机产生一个布尔型的值："+r.nextBoolean());
        System.out.println("随机产生一个双精度的值："+r.nextDouble());
        System.out.println("随机产生一个浮点值："+r.nextFloat());
        System.out.println("随即产生一个高斯分布的双精度值："+r.nextGaussian());
    }
}

应用：抢红包

import java.util.Random;
import java.util.Scanner;

public class HongBao {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        double sum1=0;
        double total = sc.nextDouble();
        double sum = total;
        int count = sc.nextInt();

        for (int i=1;i<=count-1;i++){
            double e = (double)((int)((0.01+Math.random()*(total -0.01))*100)/100.0);
            System.out.println(e);
            total-=e;
            sum1+=e;
        }
        System.out.println(String.format("%.2f",sum-sum1));
        sc.close();
    }
}

大数字运算

BigInteger类

BigInteger类型的数字范围较Integer类型的数字范围要大很多。BigInteger支持任意精度的整数，也就是说，在运算中BigInteger类型可以精确表示任何大小的整数值而不会丢失信息。

实例化BigInteger对象

两种方式

BigInteger a = new BigInteger("12345678999");
BigInteger a = BigInteger.valueOf(123456789L);

使用

import java.math.BigInteger;
import java.util.Arrays;

public class BigIntegerUse {
    public static void main(String[] args) {
        BigInteger a1 = new BigInteger("123456789999999999999");
        BigInteger a2 = BigInteger.valueOf(12345678999L);
        System.out.println("----------加法----------");
        System.out.println("a1+a2:\t"+a1.add(a2));
        System.out.println("a1+2:\t"+a1.add(new BigInteger("2")));
        System.out.println("----------减法----------");
        System.out.println("a1-a2:\t"+a1.subtract(a2));
        System.out.println("a1-2:\t"+a1.subtract(new BigInteger("2")));
        System.out.println("----------乘法----------");
        System.out.println("a1*a2:\t"+a1.multiply(a2));
        System.out.println("a1*2:\t"+a1.multiply(new BigInteger("2")));
        System.out.println("----------除法----------");
        System.out.println("a1/a2:\t"+a1.divide(a2));
        System.out.println("a1/2:\t"+a1.divide(new BigInteger("2")));
        System.out.println("----------取余----------");
        System.out.println("a1%a2:\t"+a1.remainder(a2));
        System.out.println("a1%2:\t"+a1.remainder(new BigInteger("2")));
        System.out.println("----------求余数和商----------");
        BigInteger[] a3 = Arrays.copyOf(a1.divideAndRemainder(a2),2);
        System.out.println("a1/a2的余数和商:\t");
        for (BigInteger i:a3) System.out.println(i+" ");
        System.out.println("----------乘方----------");
        System.out.println("a1^2:\t"+a1.pow(2));
        System.out.println("a1^10:\t"+a1.pow(10));
        System.out.println("----------取相反数----------");
        System.out.println("-a1:\t"+a1.negate());
        System.out.println("----------将数字左移n位（n为负数位则右移）----------");
        System.out.println("a1左移2位:\t"+a1.shiftLeft(2));
        System.out.println("a1左移-10位:\t"+a1.shiftLeft(-10));
        System.out.println("----------将数字右移n位（n为负数位则左移）----------");
        System.out.println("a1右移2位:\t"+a1.shiftRight(2));
        System.out.println("a1右移-10位:\t"+a1.shiftRight(-10));
        System.out.println("----------与操作----------");
        System.out.println("a1&a2:\t"+a1.and(a2));
        System.out.println("a1&2:\t"+a1.and(new BigInteger("2")));
        System.out.println("----------或操作----------");
        System.out.println("a1|a2:\t"+a1.or(a2));
        System.out.println("a1|2:\t"+a1.or(new BigInteger("2")));
        System.out.println("----------数字比较----------");
        System.out.println("a1与a2比较:\t"+a1.compareTo(a2));
        System.out.println("----------判断是否为BigInteger类型的数字，如果是并且数值相等，返回true----------");
        System.out.println("a1.equals(a2):\t"+a1.equals(a2));
        System.out.println("----------返回较小的数值----------");
        System.out.println("a1、a2中较小的那个:\t"+a1.min(a2));
        System.out.println("----------返回较大的数值----------");
        System.out.println("a1、大:\t"+a1.max(a2));
    }
}

----------加法----------
a1+a2: 123456790012345678998
a1+2: 123456790000000000001
----------减法----------
a1-a2: 123456789987654321000
a1-2: 123456789999999999997
----------乘法----------
a1a2: 1524157899586953209987654321001
a12: 246913579999999999998
----------除法----------
a1/a2: 10000000000
a1/2: 61728394999999999999
----------取余----------
a1%a2: 9999999999
a1%2: 1
----------求余数和商----------
a1/a2的余数和商:
10000000000
9999999999
----------乘方----------
a1^2: 15241578997104099999753086420000000000001
a1^10: 822526325771732605105307057486187608820434093602131058730405889760608348621769889730494921354438767410889123402980934791972432805147757978573308559998333022180005871054869684499998765432100000000000001
----------取相反数----------
-a1: -123456789999999999999
----------将数字左移n位（n为负数位则右移）----------
a1左移2位: 493827159999999999996
a1左移-10位: 120563271484374999
----------将数字右移n位（n为负数位则左移）----------
a1右移2位: 30864197499999999999
a1右移-10位: 126419752959999999998976
----------与操作----------
a1&a2: 8654691479
a1&2: 2
----------或操作----------
a1|a2: 123456790003690987519
a1|2: 123456789999999999999
----------数字比较----------
a1与a2比较: 1
----------判断是否为BigInteger类型的数字，如果是并且数值相等，返回true----------
a1.equals(a2): false
----------返回较小的数值----------
a1、a2中较小的那个: 12345678999
----------返回较大的数值----------
a1、大: 123456789999999999999

另外：取最大公约数

import java.math.BigInteger;

public class GreatestCommonDivisor {
    public static void main(String[] args) {
        BigInteger a1 = new BigInteger("12345678");
        BigInteger a2 = new BigInteger("23456789");
        System.out.println("a1、a2最大公约数："+a1.gcd(a2));
    }
}

a1、a2最大公约数：1

BigDecimal类

BigDecimal中加入了小数的概念。

构造方法

三种方法

字符串

BigDecimal a = new BigDecimal("3.14");

直接传入double

BigDecimal a = new BigDecimal(3.14);

valueOf

BigDecimal a = BigDecimal.valueOf(3.14);

常用方法

其他常用方法与BigInteger相同。

特殊：除法

divide()
divide(BigDecimal divisor, int scale, int roundingMode)

divisor：除数
scale：小数位数
roundingModefff：近似值的处理方式

近似值的处理方式
模式 含义
BigDecimal.ROUND_UP 商的最后一位如果大于0，则向前进位，正负数字都如此
BigDecimal.ROUND_DOWN 商的最后一位无论是什么数字，都省略
BigDecimal.ROUND_FLOOR 商如果是正数，按照ROUND_UP模式处理，如果是负数，按照ROUND_DOWN模式处理
BigDecimal.ROUND_HALF_DOWN 对商进行四舍五入，如果最后一位等于5则舍弃
BigDecimal.ROUND_HALF_UP 对商进行四舍五入，如果最后一位等于5则进位
BigDecimal.ROUND_HALF_EVEN 如果商的倒数第二位是奇数，则按照ROUND_HALF_UP处理；如果是偶数，则按照ROUND_HALF_DOWN处理。

除不尽时一定要写满三个参数，除的尽不需要

import java.math.BigDecimal;

public class BigDecimalUse {
    public static void main(String[] args) {
        BigDecimal a1 = new BigDecimal("30");
        BigDecimal a2 = new BigDecimal(7);
        BigDecimal a3 = new BigDecimal(5);
//        System.out.println(a1.divide(a2));//会报错
        System.out.println(a1.divide(a3));
        System.out.println(a1.divide(a2, 3, BigDecimal.ROUND_HALF_UP));
    }
}

6
4.286

本文地址：https://blog.csdn.net/BAOZEE/article/details/107817440

相关标签： 【Java学习记录】 java 数据分析

上一篇： 【疑问】使用numpy时shape[0]获取维度长度时提示unsubscriptable

下一篇： 2020-08-09 爬虫心得《第一篇》

推荐阅读