java科学计数怎么转换成数字

转载

网络小墨 2024-11-17 18:44:54

文章标签 java科学计数怎么转换成数字 java 开发语言实例变量局部变量 文章分类 Java 后端开发

Java基础知识-1

一、基本类型

1、数据类型

（1）两大数据类型

内置数据类型（原始数据类型）
引用数据类型

（2）float和double的区别
（3）类型转换

基本类型的赋值与转换
隐形转换
三元运算符相关转换

常量

2、变量类型

（1）类变量
（2）实例变量
（3）局部变量

3、修饰符

（1）访问控制修饰符

① public
② protected
③ default
④ private

（2）final

4、标识符命名规则
5、关键字保留字

（1）关键字
（2）保留字

6、运算符

（1）位/逻辑运算
（2）优先级
（3）移位运算符
（4）== 及 equals

① ==
② equals()
总结

二、String相关

1、StringBuffer、StringBuilder、String比较

① String
② StringBuilder
③ StringBuffer
总结

2、 subString
3、replace
4、toCharArray
5、toString
6、trim

三、数组

1、创建数组
2、二维数组
3、new与string赋值的区别
4、Arrays工具类

（1）转字符串 Arrays.toString(arr)
（2）排序 Arrays.sort(arr)
（3）填充 Arrays.fill(arr,10)
（3）判等 Arrays.equals(arr1,arr2)
（5）赋值 Arrays.copyOf(arr,arr.length)
（6）查下标 Arrays.binarySearch(arr,1)
（7）转集合 Arrays.asList(arr)

5、数组拷贝

（1）arraycopy

四、类

1、继承

（1）继承类型
（2）关键字

① extends
② implements

五、接口

1、实现
2、接口与类
3、接口与抽象类

工具类

1、Number类
2、Math类

（1）BigDecimal
（2）round
（3）floor
（4）ceil

一、基本类型

1、数据类型

（1）两大数据类型

内置数据类型（原始数据类型）

8种基本类型（6种数字类型+1种字符型+1种布尔型，注意大小写敏感）。其中，6种数字类型包括（4个整数型+2个浮点型）

byte （1个字节）;
short（2个字节）
int（4个字节）
long; （8个字节）
float; （4个字节）
double; （8个字节）
boolean; （1个字节或4个字节；boolean用于声明一个基本类型变量时，占4个字节，声明一个数组类型时，数组中每个元素占1个字节）
char; （2个字节）而Boolean则是boolean的封装类（因此需要注意大小写，boolean是原始数据类型的一种，但Boolean不是）

引用数据类型

引用类型的变量类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量，这些变量在声明时被指定为一个特定的类型。变量一旦声明后，类型就不能改变了。对象、数组都是引用数据类型；所有引用类型的默认值都是Null；一个引用变量可以用来引用任何与之兼容的类型； eg：e yvonne = new Yvonne(“Daytoy”)

（2）float和double的区别

float是单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方，float占用4个字节的存储空间double是双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的308次方，double占用8个字节的存储空间当你不声明的时候，默认小数都用double来表示，所以如果要用float的话，则应该在其后加上f 例如：float a=1.3; 则会提示不能将double转化成float 这成为窄型转化如果要用float来修饰的话，则应该使用float a=1.3f 注意float是8位有效数字，第7位数字将会产生四舍五入所以如果一个float变量这样定义: float a=1.32344435; 则第7位将产生四舍五入(5及5以下的都将舍去)

（3）类型转换

java科学计数怎么转换成数字_java

java科学计数怎么转换成数字_局部变量_02

基本类型的赋值与转换

boolean一般不参与其他类型的转化原则：表示范围大的数据不能向表示范围小的数据赋值，即使被赋值的对象可以装得下这个数据，但是系统仍然会报错：可能存在精度损失因此，上面那张图之恩顺着箭头赋值，不能逆着箭头赋值

隐形转换

低范围和高范围数据进行运算的时候，会将低范围的值向高范围的类型转化，而没这种值的类型的变化并不会传递给变量。

byte a = 10;
int b = a;//编译int b = a时，a隐式转换为int型
//
int a = 2;
double b = 5.0;
System.out.println(b/a);//此时输出b/a的值将为2.5，因为编译的时候会将a提升为b类型

byte、char、short三者可以计算，但是只要开始计算，就转化为int型 eg:

byte c1 = 1;
byte c2 = 2;
c1 + c2 // int

char c3 = 3;
c1 + c3 //int

boolean不参与运算

三元运算符相关转换

三元运算符会把两个结果的数据类型进行自动的类型提升三元运算符：一边为byte一边为char，结果为int

//即 Object o1 = true ? new Integer(1) : new Double(2.0); //可看作-> Object o1 = true ? new Double(1.0) : new Double(2.0);

//eg:
byte b = 1;
char c = 1;
short s = 1;
int i = 1;

//三目，一边为char一边为byte，结果为int
//其他情况结果为两边中范围大的，适用于包装类型
i = true ? b : c //int
b = true ? b : b //byte
s = true ? b : s //short

// 表达式，两边为byte,short,char，结果为int型
// 其它情况结果为两边中范围大的。适用包装类型
i = b + c; // int
i = b + b; // int
i = b + s; // int

// 当 a 为基本数据类型时，a += b，相当于 a = (a) (a + b)
// 当 a 为包装类型时， a += b 就是 a = a + b
b += s; // 没问题
c += i; // 没问题
 
// 常量任君搞，long以上不能越
b = (char) 1 + (short) 1 + (int) 1; // 没问题
// i = (long) 1 // 错误

常量

常量在运行过程中不能修改，java中用final修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

一般用大写字母表示常量

2、变量类型

类变量：独立于方法之外的变量，用static修饰；
实例变量：独立于方法之外的变量，没有static修饰；
局部变量：类的方法中的变量； eg:

public class Variable{
    static int allClicks = 0;//类变量
    String str = "hello world";//实例变量
    public void method() {
        int i = 0;//局部变量
    }
}

（1）类变量

（2）实例变量

实例变量声明在类中，但是在方法、构造方法和语句块之外；
当一个对象被实例化之后，实例变量的值就跟着被确定；
在对象被创建时创建，被销毁时销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方法获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对类中的方法、构造方法或者语句块是可见的，一般情况下应该把实例变量设置为私有，通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值，变量的值可以在声明时指定，也可以在构造方法中指定；

（3）局部变量

访问修饰符不能用于局部变量；
局部变量是在栈上分配的；
局部变量没有默认值，所有局部变量被声明后必须经过初始化才可以使用；
局部变量声明在方法、构造方法或者语句块种；
局部变量在方法、构造方法或者语句块被执行时创建，当它们执行完毕后，局部变量将被销毁；

3、修饰符

可以使用修饰符来修饰类中的方法和属性，主要分为2类：

访问修饰符：default、public、protected、private；
非访问修饰符：final、abstract、static、synchronized；修饰符用来定义类、方法或者变量，通常放在语句最前端。

（1）访问控制修饰符

java中使用访问控制符来保护对类、变量、方法和构造方法的访问，java支持4种不同的访问权限：

修饰符	当前类	同包	子类	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

① public

共有访问修饰符——public 如果几个相互访问的public类分布在不同的包中，则需要导入相应public类所在的包。 main()方法必须设置为public的，否则解释器不能运行该类。

② protected

受保护的访问修饰符——protected

子类与基类在同一个包中：被声明为protected的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：在子类中，子类实例可以访问其从基类继承而来的protected方法，但是不能访问基类实例的protected方法 protected可以修饰数据成员、构成方法、方法成员，不能修饰类（内部类除外）；接口及接口的成员变量和成员方法不能声明为protected；类和接口只能是public和default；接口的方法只能是public

③ default

默认访问修饰符——不使用任何关键字使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final，而接口里的方法默认访问权限为public。

④ private

私有访问修饰符是最严格的访问级别，被声明为private的方法、变量和构造方法只能为所属类访问，并且接口和类不能声明为private。声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问。

public class Logger {
    private String format;
    public String getFormat() {
        return this.format;
    }
    public void setFormat(String format) {
        this.format = format;
    }
}

如上面的例子中，Logger类中的format为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个public方法：getFormat()（返回format的值）和setFormat(String)（设置format的值）

（2）final

Java中，final可以用来修饰类、方法和变量（包括成员变量和局部变量）。

修饰类：当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式的指定为final方法。在使用final修饰类的时候，要注意慎重选择，除非这个类以后真的不会用来继承或者处于安全的考虑，尽量不要将类设计为final
修饰方法：被final修饰的方法，任何继承类不允许修改它的涵义类的private方法会被隐式的指定为final方法
修饰变量：修饰变量是final用的最多的地方。对于一个final变量，如果是基本数据类型的变量，则其数值一旦初始化后便不能更改；如果是引用类型的变量，则在对其初始化之后便不再指向另一个对象。

final与static： static作用于成员变量，用来标识只保存一份副本，而final的作用是用来保证变量不可变，可以把它类似于C语言中的宏变量

4、标识符命名规则

标识符：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符凡是自己可以起名字的都叫标识符。

命名规则：

由26各英文字母大小写、0-9、_或$组成；
数字不可以开头
不可以使用关键字和保留字
Java中严格区分大小写，长度无限制
标识符不能包含空格

5、关键字保留字

关键字和保留字均不能用作变量名、方法名、类名、包名和参数

（1）关键字

关键字中所有字母都为小写

用于定义数据类型的关键字：class interface enum byte short int long float double char boolean void
用于定义数据类型值的关键字：true false null
用于定义流程控制的关键字：if else switch case default while do for break continue return
用于定义访问权限修饰符的关键字：private protected public
用于定义类、函数、变量修饰符的关键字：abstract final static synchronized
用于定义类与类之间关系的关键字：extends implements
用于定义建立实例及引用实例、判断实例的关键字：new this super instanceof
用于异常处理的关键字：try catch finally throw throws
用于包的关键字：package import
其他修饰符关键字：native strictfp transient volatile assert

（2）保留字

即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其他语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。 eg:const goto

6、运算符

（1）位/逻辑运算

首先名称是不同的＆＆逻辑与　　｜｜逻辑或　　它们都是逻辑运算符＆　按位与　　｜　按位或　　它们都是位运算符ｉｆ（ａ＝＝１＆＆ｂ＝＝２）　这是说既要满足ａ＝１也要满足ｂ＝２ｉｆ（ａ＝＝１｜｜ｂ＝＝２）　这是说或者满足ａ＝１或者要满足ｂ＝２

而ａ＆ｂ或者ａ｜ｂ则是二进制的与或运算＆同为１时为１，否则为０｜同为０时为０，否则为１

（2）优先级

java科学计数怎么转换成数字_实例变量_03

（3）移位运算符

<<,>>,>>>为java中的移位运算符。

<<表示左移运算符：例如8<<2,表示将8向左移2位，结果为32。低位补0。二进制演算： 8的二进制：1 0 0 0 向左移动两位结果为1 0 0 0 0 0，换算成十进制即为32，也可以简单的理解为，左移就是将数变大，相当8*2^2=32。左移运算符的运算规律：将左边的数按照右边的数往左移动几位。
”>>”表示右移运算符：例如 8>>2,表示将8向右移动2位，结果为2。高位补0。二进制演算： 8的二进制：1 0 0 0 向右移动两位：0 0 1 0即为2，也可以简单的理解为将数向右移位就是将数变小，相当于8除以2^2=2。右移运算符运算规律：将左边的数按照右边的数右移几位。（算术右移）
”>>>”表示无符号右移运算符：高位补0例如8>>>2表示将8向右移位2位，结果为2。这个也可以和右移运算符一起理解。(逻辑右移)

（4）== 及 equals

① ==

比较的是值，对于基本数据类型的比较易懂，而对于引用类型，比如String等，则是比较二者地址是否一样示例：

public static void main(String[] args) {
    int n = 3;
    int m = 3;
    System.out.println(n == m);
    String str = new String("hello");
    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println(str1 == str2);
    str1 = str;
    str2 = str;
    System.out.println(str1 == str2);
}

输出结果如下：

java科学计数怎么转换成数字_java科学计数怎么转换成数字_04

如图中，

第一次比较，为int基本类型的比较，结果为true；

第二次比较，为String类型，为引用类型，String存储的是指向对象的地址，二者存储地址不同，因此结果为false

第三次比较，都让str1和str2指向了str指向的对象，因此结果为true

② equals()

equals方法是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。即不能用equals()比较基本类型。

总结

1）对于==，比较的是值是否相等如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；　　如果作用于引用类型的变量，则比较的是所指向的对象的地址 2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

二、String相关

1、StringBuffer、StringBuilder、String比较

运行速度：StringBuilder > StringBuffer > String

① String

String是字符串常量 java中字符串属于对象，java提供了String类来创建和操作字符串。 String是只读字符串 String类是不可改变的，所以一旦创建了String对象，那么它的值就无法改变了，如果需要对字符串进行修改，那么应该选择使用StringBuffer & StringBuilder类。

② StringBuilder

字符串变量与String不同，StringBuffer和StringBuilder类的对象能够被多次修改，并且不产生新的未使用对象。

③ StringBuffer

字符串变量与String不同，StringBuffer和StringBuilder类的对象能够被多次修改，并且不产生新的未使用对象。

总结

当对字符串进行修改的时候需要使用StringBuffer/StringBuilder类。 StringBuilder与StringBuffer最大的不同在于StringBuilder的方法不是线程安全的（不能同步访问）。由于StringBuilder相较于StringBuffer有速度优势，因此多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下则必须使用StringBuffer类。

public class Test {
    public static void main(String args[]) {
        StringBuffer sBuffer = new StringBuffer('菜鸟官网：');
        sBuffer.append('www');
        sBuffer.append('.baidu');
        sBuffer.append('.com');
        System.out.println(sBuffer);//菜鸟官网：www.baidu.com
    }
}

2、 subString

subString是否始终返回一个新串？ ——否。 subString只有在截取的子串是真子串（真子串指子串与原串不相同）时才返回一个新声明的子串。当截取的是整个字符串时，则返回自身。语法： String subString(int begin) String subString(int begin, int end)

3、replace

replace方法是否始终返回一个新串？一般是这样。但如果要替代的字符与新字符一样，则返回自身.

4、toCharArray

toCharArray方法返回String对象内置的字符数组？——否。方法返回的是一个崭新的字符数组，且空间分配在堆空间。所以对该方法返回的字符数组进行修改，不会对String对象产生任何影响。

5、toString

toString方法返回的是一个新的String对象吗？——否。该方法返回的就是自身。

6、trim

trim方法始终返回一个新的String对象吗？——否。并不总是这样。首先trim返回String对象的一个副本，该副本去除了原来字符串中的首部和尾部空白。但如果String对象首部和尾部没有空白的话，则返回自身。否则调用subString方法返回一个崭新的String对象（真子串，subString中有所提到）

三、数组

1、创建数组

arrayRefVar = new dataType[arraySize];
//使用dataType[arraySize]创建了一个数组；把新建的数组引用赋值给arrayRefvar;

//数组变量的声明和创建数组可以用一条语句完成：
dataType[] arrayRefVar = new dataType[arraySize]
//除此之外，还有以下方法：
dataType[] arrayRefVar = {1,2,3,...,100};

2、二维数组

二维数组定义，一维长度必须定义，二维可以后续定义

fload f[][] = new float[6][6]  // 正确
float []f[] = new float[6][6]  // 正确
fload [][]f = new float[6][6]  // 正确
fload [][]f = new float[6][]   // 正确
fload f[][] = new float[][6]   // 错误

3、new与string赋值的区别

java科学计数怎么转换成数字_实例变量_05

String a = "hello";
String b = a.substring(2,3);
String c = a.toString();
String d = new StringBuffer(a).toString();

System.out.println(a == c);//true
System.out.println(a.equals(c));//true
System.out.println(a == d);//false
System.out.println(a.equals(d));//true

—— 问：下述语句创建了几个String Object？

String s = new String("xyz");

答：创建了2个因为每new一次就会创建一次

4、Arrays工具类

Arrays 是JDK提供的操作数组的工具类，array类提供了动态创建和访问 Java 数组的方法。 arrays此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。最常用的就是asList,sort,toString,equals,copyOf了

（1）转字符串 Arrays.toString(arr)

System.out.println("转换前："+a);
//数组转换字符串
String str=Arrays.toString(a);       
System.out.println("转换为字符串："+str);

运行结果如下：

java科学计数怎么转换成数字_局部变量_06

（2）排序 Arrays.sort(arr)

关于sort()的用法参考：link 该文章中，不仅包含数组排序，还包括集合排序，这里暂时仅介绍数组排序sort方法。数组排序：

int a[] ={20,3,32,1,72,26,35};
System.out.println("原数组："+Arrays.toString(a));
Arrays.sort(a);
System.out.println("排序后数组："+Arrays.toString(a));

运行结果如下：

java科学计数怎么转换成数字_局部变量_07

（3）填充 Arrays.fill(arr,10)

所有元素赋特定值fill（基于目标元素填充数组）

int a[] ={20,3,32,1,72,26,35};
System.out.println("赋值前："+Arrays.toString(a));
Arrays.fill(a,10);
System.out.println("赋值后："+Arrays.toString(a));

运行结果如下：

java科学计数怎么转换成数字_开发语言_08

（3）判等 Arrays.equals(arr1,arr2)

int a[] ={20,3,32,1,72,26,35};
int b[]={3,5,7,8,54,23,9};
int c[]={3,5,7,8,54,23,9};
boolean boo1 = Arrays.equals(a,b);
boolean boo2 = Arrays.equals(b,c);
System.out.println("a:"+Arrays.toString(a));
System.out.println("b:"+Arrays.toString(b));
System.out.println("c:"+Arrays.toString(c));
System.out.println("a与b是否相等："+boo1);
System.out.println("b与c是否相等："+boo2);

运行结果如下：

java科学计数怎么转换成数字_开发语言_09

（5）赋值 Arrays.copyOf(arr,arr.length)

int b[]={3,5,7,8,54,23,9};
int d[] = Arrays.copyOf(b,b.length);
System.out.println("d:"+Arrays.toString(d));
System.out.println("b:"+Arrays.toString(b));

运行结果如下：

java科学计数怎么转换成数字_开发语言_10

（6）查下标 Arrays.binarySearch(arr,1)

int b[]={3,5,7,8,54,23,9};
int i = Arrays.binarySearch(b,5);
System.out.println("数组b数字5所在的下标是:"+i);

运行结果如下：

java科学计数怎么转换成数字_开发语言_11

（7）转集合 Arrays.asList(arr)

int a[] ={20,3,32,1,72,26,35};
//数组转换成字符串
String str = Arrays.toString(a);
//字符串转换成集合
List<String> list = Arrays.asList(str);
for(int i=0;i<list.size();i++) {
    System.out.println("转换后的List集合:"+list.get(i));
}

运行结果如下：

java科学计数怎么转换成数字_实例变量_12

5、数组拷贝

（1）arraycopy

link arraycopy()方法用于将一个数组的元素快速拷贝到另一个数组。其中的参数如下：

System.arraycopy(src, srcPos, dest, destPos, length);

src：表示源数组srcPos：表示源数组中拷贝元素的起始位置。dest：表示目标数组destPos：表示拷贝到目标数组的起始位置length：表示拷贝元素的个数

需要注意的问题：

在进行数组拷贝时，目标数组必须有足够的空间来存放拷贝的元素，否则就会发生角标越界异常。
目标数组相对应位置上的元素会被覆盖掉；

四、类

1、继承

Java中，子类不能继承父类的私有属性

（1）继承类型

java不支持多继承，但支持多重继承

java科学计数怎么转换成数字_局部变量_13

（图源自link）

（2）关键字

继承可以使用extends和implements这两个关键字来实现继承，而且所有的类都是继承于java.lang.Object，当一个类没有继承的两个关键字，则默认继承object祖先类。

① extends

在java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以extends只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

② implements

使用implements关键字可以变相的使java具有多继承的特性，适用范围为类继承接口的情况，同时可以继承多个接口（接口和接口之间用逗号分开）

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

五、接口

接口在Java中是一个抽象类型，是抽象方法的集合，通常以interface来声明，一个类通过继承接口的方式从而来继承接口的抽象方法。 **接口无法被实例化，但是可以被实现。**一个实现接口的类，必须实现接口内描述的所有方法，否则就必须声明为抽象类。另外，接口类型可以用来声明一个变量，他们可以成为一个空指针，或者是被绑定在一个以此接口实现的对象。

1、实现

接口的实现当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。 **类使用implements关键字实现接口。**在类声明中，Implements关键字放在class声明后面。实现一个接口的语法，可以使用这个公式：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

一个类可以同时实现多个接口。
一个类只能继承一个类，但是能实现多个接口。
一个接口能继承另一个接口，这和类之间的继承比较相似。

类不允许多继承，但是接口运行多继承

public interface Hockey extends Sports, Event

2、接口与类

接口不是类。编写接口的方式和类很相似。类描述对象的属性和方法，接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

3、接口与抽象类

接口中所有的方法隐含的都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法
类可以实现很多接口，但只能继承一个抽象类；
类可以实现抽象类和接口声明的所有方法，当然，这种情况下，类也必须声明成抽象的
抽象类可以在不提供接口实现方法的情况下实现接口
Java接口中声明的变量默认为final，抽象类可以包含非final的变量
Java接口中的成员函数默认是public，抽象类的成员函数也可以是private、protected或者public
接口是绝对抽象的，不可以被实例化，抽象类也不可以被实例化
一个类实现接口的话要实现接口的所有方法，而抽象类不一定。

从设计层面上来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为规范。

工具类

1、Number类

一般当需要使用数字的时候，我们通常用内置数据类型，如：byte、

int、long、double等
int a = 5000;
float b = 13.65f;
byte c = 0x4a;

但是实际开发中我们经常会遇到需要使用对象，而不是内置数据类型的情况，为了解决这个问题，java为每个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类

java科学计数怎么转换成数字_实例变量_14

（图源自link）

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

public class Test{
    public static void main(String args[]) {
        Integer x = 5;
        x = x+10;
        System.out.println(x);//15
    }
}

2、Math类

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

public class Test {
    public static void main(String []args) {
        System.out.println(Math.sin(Math.PI/2));
        //90度的正切值，输出1.0
    }
}

（1）BigDecimal

link Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

**构造器描述 **

BigDecimal(int) 创建一个具有参数所指定整数值的对象。
BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 //不推荐使用
BigDecimal(long) 创建一个具有参数所指定长整数值的对象。
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用

**方法描述 **

add(BigDecimal) BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal) BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal) BigDecimal对象中的值相除，然后返回这个对象。
toString() 将BigDecimal对象的数值转换成字符串，有必要时使用科学计数法。
toPlainString() 将BigDecimal对象的数值转换成字符串，不使用任何指数
toEngineeringString() 将BigDecimal对象的数值转换成字符串，有必要时使用工程计数法。工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数
doubleValue() 将BigDecimal对象中的值以双精度数返回。
floatValue() 将BigDecimal对象中的值以单精度数返回。
longValue() 将BigDecimal对象中的值以长整数返回。
intValue() 将BigDecimal对象中的值以整数返回。
signum() 如果此BigDecimal<0, 则为-1;如果 = 0，则为0;如果> 0, 则为1

java.math.BigDecimal.subtract()方法实例link

BigDecimal的3个toString方法

toEngineeringString：有必要时使用工程计数法。工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数
toPlainString：不使用任何指数
toString：有必要时使用科学计数法示例：

import java.math.BigDecimal;
public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal bg = new BigDecimal("1E11");
        System.out.println(bg.toEngineeringString());//100E+9
        System.out.println(bg.toPlainString());//100000000000
        System.out.println(bg.toString());//1E+11
    }
}

（2）round

Math.round()：

System.out.println(Math.round(11.3));//11
System.out.println(Math.round(-11.3));//-11
System.out.println(Math.round(11.5));//12
System.out.println(Math.round(-11.5));//-11
System.out.println(Math.round(11.7));//12
System.out.println(Math.round(-11.7));//-12

返回值为long或者int类型，即类似与四舍五入取整数正数四舍五入负数绝对值，小于等于5，直接舍去小数部分，大于5，则返回一个绝对值大于的最小整数（实际应该是小于）

（3）floor

Math.floor()：

System.out.println(Math.floor(11.3));//11.0
System.out.println(Math.floor(-11.3));//-12.0
System.out.println(Math.floor(11.5));//11.0
System.out.println(Math.floor(-11.5));//-12.0
System.out.println(Math.floor(11.7));//11.0
System.out.println(Math.floor(-11.7));//-12.0

返回值为double类型，返回一个小于或等于参数的最大整数，即舍去

（4）ceil

Math.ceil()：

System.out.println(Math.ceil(11.3));//12.0
System.out.println(Math.ceil(-11.3));//-11.0
System.out.println(Math.ceil(11.5));//12.0
System.out.println(Math.ceil(-11.5));//-11.0
System.out.println(Math.ceil(11.7));//12.0
System.out.println(Math.ceil(-11.7));//-11.0

返回值为double类型，返回一个大于或等于参数的最小整数，即进一

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：设备虚拟化未开启

下一篇：python怎么开启wss服务器

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯