Java 基础类型属性笔记

2022-05-30 约 6015 字预计阅读 13 分钟次阅读

/java-basicclass-note/featured-image.jpg

Java代码实现double类型数字格式化为百分数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class PercentTest {
	public static void main(String[] args) {
		double rate = 0.26535;
		NumberFormat nf = NumberFormat.getPercentInstance();
		nf.setMinimumFractionDigits(2);//设置保留小数位,小数点后保留位数
         nf.setMaximumFractionDigits(2);//小数点前保留位数
		nf.setRoundingMode(RoundingMode.HALF_UP); //设置舍入模式
		String percent = nf.format(rate);
		System.out.println(percent);
	}
}

舍入模式 UP：远离零方向舍入的舍入模式。始终对非零舍弃部分前面的数字加 1。注意，此舍入模式始终不会减少计算值的绝对值。

示例：

输入数字	使用 UP 舍入模式
5.5	6
2.5	3
1.6	2
1.1	2
1.0	1
-1.0	-1
-1.1	-2
-1.6	-2
-2.5	-3
-5.5	-6

DOWN：向零方向舍入的舍入模式。从不对舍弃部分前面的数字加 1（即截尾）。注意，此舍入模式始终不会增加计算值的绝对值。

示例：

输入数字	使用 DOWN 舍入模式
5.5	5
2.5	2
1.6	1
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-1
-2.5	-2
-5.5	-5

CEILING：向正无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.UP；如果结果为负，则舍入行为类似于 RoundingMode.DOWN。注意，此舍入模式始终不会减少计算值。

示例：

输入数字	使用 CEILING 舍入模式
5.5	6
2.5	3
1.6	2
1.1	2
1.0	1
-1.0	-1
-1.1	-1
-1.6	-1
-2.5	-2
-5.5	-5

FLOOR：向负无限大方向舍入的舍入模式。如果结果为正，则舍入行为类似于 RoundingMode.DOWN；如果结果为负，则舍入行为类似于RoundingMode.UP。注意，此舍入模式始终不会增加计算值。

示例：

输入数字	使用 FLOOR 舍入模式
5.5	5
2.5	2
1.6	1
1.1	1
1.0	1
-1.0	-1
-1.1	-2
-1.6	-2
-2.5	-3
-5.5	-6

HALF_UP：

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。如果被舍弃部分 >= 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同RoundingMode.DOWN。注意，此舍入模式就是通常学校里讲的四舍五入。

示例：

输入数字	使用 HALF_UP 舍入模式
5.5	6
2.5	3
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-3
-5.5	-6

HALF_DOWN：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。如果被舍弃部分 > 0.5，则舍入行为同 RoundingMode.UP；否则舍入行为同RoundingMode.DOWN。

示例：

输入数字	使用 HALF_DOWN 舍入模式
5.5	5
2.5	2
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-2
-5.5	-5

HALF_EVEN：

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为同 RoundingMode.HALF_UP；如果为偶数，则舍入行为同RoundingMode.HALF_DOWN。注意，在重复进行一系列计算时，此舍入模式可以在统计上将累加错误减到最小。此舍入模式也称为“银行家舍入法”，主要在美国使用。此舍入模式类似于 Java 中对float 和double 算法使用的舍入策略。

示例：

输入数字	使用 HALF_EVEN 舍入模式
5.5	6
2.5	2
1.6	2
1.1	1
1.0	1
-1.0	-1
-1.1	-1
-1.6	-2
-2.5	-2
-5.5	-6

UNNECESSARY：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。如果对生成精确结果的操作指定此舍入模式，则抛出 ArithmeticException。

示例：

输入数字	使用 UNNECESSARY 舍入模式
5.5	抛出 ArithmeticException
2.5	抛出 ArithmeticException
1.6	抛出 ArithmeticException
1.1	抛出 ArithmeticException
1.0	1
-1.0	-1
-1.1	抛出 ArithmeticException
-1.6	抛出 ArithmeticException
-2.5	抛出 ArithmeticException
-5.5	抛出 ArithmeticException

BigDecimal

几种舍弃精度的算法

测试代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


        double i = 2, j = 2.4, k = 2.5, l = 2.6, m = 2.9;

        System.out.println("五舍六入取整:Math.rint(2)=" + (int) Math.rint(i));
        System.out.println("五舍六入取整:Math.rint(2.4=" + (int) Math.rint(j));
        System.out.println("五舍六入取整:Math.rint(2.5)=" + (int) Math.rint(k));
        System.out.println("五舍六入取整:Math.rint(2.6)=" + (int) Math.rint(l));
        System.out.println("五舍六入取整:Math.rint(2.9)=" + (int) Math.rint(m));
        System.out.println("五舍六入取整: new DecimalFormat(2)=" + new DecimalFormat("0").format(i));
        System.out.println("五舍六入取整: new DecimalFormat(2.4)=" + new DecimalFormat("0").format(i));
        System.out.println("五舍六入取整: new DecimalFormat(2.5)=" + new DecimalFormat("0").format(i));
        System.out.println("五舍六入取整: new DecimalFormat(2.6)=" + new DecimalFormat("0").format(l));
        System.out.println("五舍六入取整: new DecimalFormat(2.9)=" + new DecimalFormat("0").format(i));

        System.out.println("五舍六入取整:Math.rint(-2)=" + (int) Math.rint(-i));
        System.out.println("五舍六入取整:Math.rint(-2.4=" + (int) Math.rint(-j));
        System.out.println("五舍六入取整:Math.rint(-2.5)=" + (int) Math.rint(-k));
        System.out.println("五舍六入取整:Math.rint(-2.6)=" + (int) Math.rint(-l));
        System.out.println("五舍六入取整:Math.rint(-2.9)=" + (int) Math.rint(-m));
        System.out.println("五舍六入取整: new DecimalFormat(-2)=" + new DecimalFormat("0").format(-i));
        System.out.println("五舍六入取整: new DecimalFormat(-2.4)=" + new DecimalFormat("0").format(-i));
        System.out.println("五舍六入取整: new DecimalFormat(-2.5)=" + new DecimalFormat("0").format(-i));
        System.out.println("五舍六入取整: new DecimalFormat(-2.6)=" + new DecimalFormat("0").format(-l));
        System.out.println("五舍六入取整: new DecimalFormat(-2.9)=" + new DecimalFormat("0").format(-i));

        System.out.println("舍掉小数取整:Math.floor(2)=" + (int) Math.floor(i));
        System.out.println("舍掉小数取整:Math.floor(2.4)=" + (int) Math.floor(j));
        System.out.println("舍掉小数取整:Math.floor(2.5)=" + (int) Math.floor(k));
        System.out.println("舍掉小数取整:Math.floor(2.6)=" + (int) Math.floor(l));
        System.out.println("舍掉小数取整:Math.floor(2.9)=" + (int) Math.floor(m));
        System.out.println("四舍五入取整:new BigDecimal(2).setScale=" + new BigDecimal("2").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(2.4).setScale=" + new BigDecimal("2.1").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(2.5).setScale=" + new BigDecimal("2.5").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(2.6).setScale=" + new BigDecimal("2.6").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(2.9).setScale=" + new BigDecimal("2.9").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("凑整:Math.ceil(2)=" + (int) Math.ceil(i));
        System.out.println("凑整:Math.ceil(2.4)=" + (int) Math.ceil(j));
        System.out.println("凑整:Math.ceil(2.5)=" + (int) Math.ceil(k));
        System.out.println("凑整:Math.ceil(2.6)=" + (int) Math.ceil(l));
        System.out.println("凑整:Math.ceil(2.9)=" + (int) Math.ceil(m));

        System.out.println("舍掉小数取整:Math.floor(-2)=" + (int) Math.floor(-i));
        System.out.println("舍掉小数取整:Math.floor(-2.4)=" + (int) Math.floor(-j));
        System.out.println("舍掉小数取整:Math.floor(-2.5)=" + (int) Math.floor(-k));
        System.out.println("舍掉小数取整:Math.floor(-2.6)=" + (int) Math.floor(-l));
        System.out.println("舍掉小数取整:Math.floor(-2.9)=" + (int) Math.floor(-m));
        System.out.println("四舍五入取整:new BigDecimal(-2).setScale=" + new BigDecimal("-2").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(-2.4).setScale=" + new BigDecimal("-2.1").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(-2.5).setScale=" + new BigDecimal("-2.5").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(-2.6).setScale=" + new BigDecimal("-2.6").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("四舍五入取整:new BigDecimal(-2.9).setScale=" + new BigDecimal("-2.9").setScale(0, BigDecimal.ROUND_HALF_UP));
        System.out.println("凑整:Math.ceil(-2)=" + (int) Math.ceil(-i));
        System.out.println("凑整:Math.ceil(-2.4)=" + (int) Math.ceil(-j));
        System.out.println("凑整:Math.ceil(-2.5)=" + (int) Math.ceil(-k));
        System.out.println("凑整:Math.ceil(-2.6)=" + (int) Math.ceil(-l));
        System.out.println("凑整:Math.ceil(-2.9)=" + (int) Math.ceil(-m));

运行结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


五舍六入取整:Math.rint(2)=2
五舍六入取整:Math.rint(2.4=2
五舍六入取整:Math.rint(2.5)=2
五舍六入取整:Math.rint(2.6)=3
五舍六入取整:Math.rint(2.9)=3
五舍六入取整: new DecimalFormat(2)=2
五舍六入取整: new DecimalFormat(2.4)=2
五舍六入取整: new DecimalFormat(2.5)=2
五舍六入取整: new DecimalFormat(2.6)=3
五舍六入取整: new DecimalFormat(2.9)=2
五舍六入取整:Math.rint(-2)=-2
五舍六入取整:Math.rint(-2.4=-2
五舍六入取整:Math.rint(-2.5)=-2
五舍六入取整:Math.rint(-2.6)=-3
五舍六入取整:Math.rint(-2.9)=-3
五舍六入取整: new DecimalFormat(-2)=-2
五舍六入取整: new DecimalFormat(-2.4)=-2
五舍六入取整: new DecimalFormat(-2.5)=-2
五舍六入取整: new DecimalFormat(-2.6)=-3
五舍六入取整: new DecimalFormat(-2.9)=-2
舍掉小数取整:Math.floor(2)=2
舍掉小数取整:Math.floor(2.4)=2
舍掉小数取整:Math.floor(2.5)=2
舍掉小数取整:Math.floor(2.6)=2
舍掉小数取整:Math.floor(2.9)=2
四舍五入取整:new BigDecimal(2).setScale=2
四舍五入取整:new BigDecimal(2.4).setScale=2
四舍五入取整:new BigDecimal(2.5).setScale=3
四舍五入取整:new BigDecimal(2.6).setScale=3
四舍五入取整:new BigDecimal(2.9).setScale=3
凑整:Math.ceil(2)=2
凑整:Math.ceil(2.4)=3
凑整:Math.ceil(2.5)=3
凑整:Math.ceil(2.6)=3
凑整:Math.ceil(2.9)=3
舍掉小数取整:Math.floor(-2)=-2
舍掉小数取整:Math.floor(-2.4)=-3
舍掉小数取整:Math.floor(-2.5)=-3
舍掉小数取整:Math.floor(-2.6)=-3
舍掉小数取整:Math.floor(-2.9)=-3
四舍五入取整:new BigDecimal(-2).setScale=-2
四舍五入取整:new BigDecimal(-2.4).setScale=-2
四舍五入取整:new BigDecimal(-2.5).setScale=-3
四舍五入取整:new BigDecimal(-2.6).setScale=-3
四舍五入取整:new BigDecimal(-2.9).setScale=-3
凑整:Math.ceil(-2)=-2
凑整:Math.ceil(-2.4)=-2
凑整:Math.ceil(-2.5)=-2
凑整:Math.ceil(-2.6)=-2
凑整:Math.ceil(-2.9)=-2

特殊的情况

将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。返回的 BigDecimal 的标度是使 $ (10^{scale} × val) $为整数的最小值。

Java中如何将int 类型转换为 Long类型

1

Long l = (Long)3;

很多同学可能会用上面的方法将int类型转换为Long类型，但事实上这样是不可行的。因为Long是包装类，而int是值类型数据，两者是不能这样强转的。

1

long l = (long)3;

int和long都是基本类型的数据，是可以强转的，那么我就可以以此作为桥梁，强转成long后，再生成Long类型的数据。

1

Long l = new Long((long)3);

这样就可以将int类型顺利转换为Long类型。

还有这种

1

Long waitTime = Long.valueOf(String.valueOf((10 * 60 * 1000) / 5));

Java中Integer和int之间的转换

int到Integer:

1
2


int a=3;
Integer A=new Integer(a);

或:

1

Integer A=Integer.valueOf(a);

Integer到int:

1
2


Integer A=new Integer(5);
int a=A.intValue();

至于Integer.parseInt(String str)则是将String类型转为int类型。

int类型是放在栈空间的，Integer是作为对象放在堆空间的;
int 是基本类型，不是类，为了符合面向对象编程,后来出现了Integer 类,他是对int进行封装的。
int不是对象，是java原始的数据类型，它默认值为0。
Integer是个对象，它有自己的方法，默认值为NULL。

实现这种对象包装的目的主要是因为类能够提供必要的方法，用于实现基本数据类型的数值与可打印字符串之间的转换，以及一些其他的实用程序方法；另外，有些数据结构库类只能操作对象，而不支持基本数据类型的变量，包装类提供一种便利的方式，能够把基本数据类型转换成等价的对象，从而可以利用数据结构库类进行处理。

Java的三种随机数生成方式

随机数的产生在一些代码中很常用，也是我们必须要掌握的。而java中产生随机数的方法主要有三种：

第一种：new Random()
第二种：Math.random()
第三种：currentTimeMillis()

第一种

第一种需要借助java.util.Random类来产生一个随机数发生器，也是最常用的一种，构造函数有两个，Random()和Random(long seed)。第一个就是以当前时间为默认种子，第二个是以指定的种子值进行。产生之后，借助不同的语句产生不同类型的数。

种子就是产生随机数的第一次使用值,机制是通过一个函数,将这个种子的值转化为随机数空间中的某一个点上,并且产生的随机数均匀的散布在空间中。以后产生的随机数都与前一个随机数有关。以代码为例。

1
2
3
4
5
6
7


public static void main(String[] args) {
    Random r = new Random(1);
    for (int i = 0; i < 5; i++) {
        int ran1 = r.nextInt(100);
        System.out.println(ran1);
    }
}

在我的编译器下产生的五个数均为85,88,47,13,54，如果采用Random r = new Random()，产生的随机数就不同，这就是确定种子导致的结果。

第二种

而第二种方法返回的数值是[0.0,1.0）的double型数值，由于double类数的精度很高，可以在一定程度下看做随机数，借助（int）来进行类型转换就可以得到整数随机数了，代码如下。

1
2
3
4
5


public static void main(String[] args){    
    int max=100,min=1;
    int ran2 = (int) (Math.random()*(max-min)+min); 
    System.out.println(ran2);
}

第三种

至于第三种方法虽然不常用，但是也是一种思路。方法返回从1970年1月1日0时0分0秒（这与UNIX系统有关）到现在的一个long型的毫秒数，取模之后即可得到所需范围内的随机数。

1
2
3
4
5
6
7


public static void main(String[] args){    
    int max=100,min=1;
    long randomNum = System.currentTimeMillis();  
    int ran3 = (int) (randomNum%(max-min)+min);  
    System.out.println(ran3);
    
}

目录