mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-16 18:10:13 +08:00
[docs improve]java基础部分内容完善
This commit is contained in:
guide
parent
689d00f79f
commit
80d9e98cb6
@ -7,13 +7,7 @@ tag:
|
||||
|
||||
《阿里巴巴 Java 开发手册》中提到：“为了避免精度丢失，可以使用 `BigDecimal` 来进行浮点数的运算”。
|
||||
|
||||
这篇文章，我就简单解释一下浮点数运算出现精度丢失的原因以及 `BigDecimal` 的常见用法，希望对大家有帮助！
|
||||
|
||||
## BigDecimal 介绍
|
||||
|
||||
`BigDecimal` 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 `BigDecimal` 来做的。
|
||||
|
||||
纳尼，浮点数的运算竟然还会有精度丢失的风险吗？确实会！
|
||||
浮点数的运算竟然还会有精度丢失的风险吗？确实会！
|
||||
|
||||
示例代码：
|
||||
|
||||
@ -44,25 +38,19 @@ System.out.println(a == b);// false
|
||||
|
||||
关于浮点数的更多内容，建议看一下[计算机系统基础（四）浮点数](http://kaito-kidd.com/2018/08/08/computer-system-float-point/)这篇文章。
|
||||
|
||||
## BigDecimal 的用处
|
||||
## BigDecimal 介绍
|
||||
|
||||
《阿里巴巴 Java 开发手册》中提到：**浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。**
|
||||
`BigDecimal` 可以实现对浮点数的运算，不会造成精度丢失。
|
||||
|
||||
通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 `BigDecimal` 来做的。
|
||||
|
||||
《阿里巴巴 Java 开发手册》中提到：**浮点数之间的等值判断，基本数据类型不能用 == 来比较，包装数据类型不能用 equals 来判断。**
|
||||
|
||||
|
||||
|
||||
具体原因我们在上面已经详细介绍了，这里就不多提了，我们下面直接上实例：
|
||||
具体原因我们在上面已经详细介绍了，这里就不多提了。
|
||||
|
||||
```java
|
||||
float a = 1.0f - 0.9f;
|
||||
float b = 0.9f - 0.8f;
|
||||
System.out.println(a);// 0.100000024
|
||||
System.out.println(b);// 0.099999964
|
||||
System.out.println(a == b);// false
|
||||
```
|
||||
|
||||
从输出结果就可以看出发生精度丢失的问题。
|
||||
|
||||
想要解决这个问题也很简单，直接使用 `BigDecimal` 来定义浮点数的值，再进行浮点数的运算操作即可。
|
||||
想要解决浮点数运算精度丢失这个问题，可以直接使用 `BigDecimal` 来定义浮点数的值，然后再进行浮点数的运算操作即可。
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1.0");
|
||||
@ -72,13 +60,19 @@ BigDecimal c = new BigDecimal("0.8");
|
||||
BigDecimal x = a.subtract(b);
|
||||
BigDecimal y = b.subtract(c);
|
||||
|
||||
System.out.println(x); /* 0.1 */
|
||||
System.out.println(y); /* 0.1 */
|
||||
System.out.println(Objects.equals(x, y)); /* true */
|
||||
System.out.println(x.compareTo(y));// 0
|
||||
```
|
||||
|
||||
## BigDecimal 常见方法
|
||||
|
||||
### 创建
|
||||
|
||||
我们在使用 `BigDecimal` 时，为了防止精度丢失，推荐使用它的`BigDecimal(String val)`构造方法或者 `BigDecimal.valueOf(double val)` 静态方法来创建对象。
|
||||
|
||||
《阿里巴巴 Java 开发手册》对这部分内容也有提到，如下图所示。
|
||||
|
||||
|
||||
|
||||
### 加减乘除
|
||||
|
||||
`add` 方法用于将两个 `BigDecimal` 对象相加，`subtract` 方法用于将两个 `BigDecimal` 对象相减。`multiply` 方法用于将两个 `BigDecimal` 对象相乘，`divide` 方法用于将两个 `BigDecimal` 对象相除。
|
||||
@ -144,13 +138,33 @@ BigDecimal n = m.setScale(3,RoundingMode.HALF_DOWN);
|
||||
System.out.println(n);// 1.255
|
||||
```
|
||||
|
||||
## BigDecimal 的使用注意事项
|
||||
## BigDecimal 等值比较问题
|
||||
|
||||
注意：我们在使用 `BigDecimal` 时，为了防止精度丢失，推荐使用它的`BigDecimal(String val)`构造方法或者 `BigDecimal.valueOf(double val)` 静态方法来创建对象。
|
||||
《阿里巴巴 Java 开发手册》中提到：
|
||||
|
||||
《阿里巴巴 Java 开发手册》对这部分内容也有提到，如下图所示。
|
||||
|
||||
|
||||
|
||||
`BigDecimal` 使用 `equals()` 方法进行等值比较出现问题的代码示例：
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1");
|
||||
BigDecimal b = new BigDecimal("1.0");
|
||||
System.out.println(a.equals(b));//false
|
||||
```
|
||||
|
||||
这是因为 `equals()` 方法不仅仅会比较值的大小（value）还会比较精度（scale），而 `compareTo()` 方法比较的时候会忽略精度。
|
||||
|
||||
1.0 的 scale 是 1，1 的 scale 是 0，因此 `a.equals(b)` 的结果是 false。
|
||||
|
||||
|
||||
|
||||
`compareTo()` 方法可以比较两个 `BigDecimal` 的值，如果相等就返回 0，如果第 1 个数比第 2 个数大则返回 1，反之返回-1。
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1");
|
||||
BigDecimal b = new BigDecimal("1.0");
|
||||
System.out.println(a.compareTo(b));//0
|
||||
```
|
||||
|
||||
## BigDecimal 工具类分享
|
||||
|
||||
@ -342,4 +356,3 @@ public class BigDecimalUtil {
|
||||
浮点数没有办法用二进制精确表示，因此存在精度丢失的风险。
|
||||
|
||||
不过，Java 提供了`BigDecimal` 来操作浮点数。`BigDecimal` 的实现利用到了 `BigInteger` （用来操作大整数）, 所不同的是 `BigDecimal` 加入了小数位的概念。
|
||||
|
||||
|
||||
@ -56,7 +56,7 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有
|
||||
|
||||
> HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。
|
||||
|
||||
### 为什么不全部使用AOT呢？
|
||||
### 为什么不全部使用 AOT 呢？
|
||||
|
||||
AOT 可以提前编译节省启动时间，那为什么不全部使用这种编译方式呢？
|
||||
|
||||
@ -107,19 +107,19 @@ AOT 可以提前编译节省启动时间，那为什么不全部使用这种编
|
||||
|
||||
6. Oracle JDK 使用 BCL/OTN 协议获得许可，而 OpenJDK 根据 GPL v2 许可获得许可。
|
||||
|
||||
>既然 Oracle JDK 这么好，那为什么还要有 OpenJDK？
|
||||
> 既然 Oracle JDK 这么好，那为什么还要有 OpenJDK？
|
||||
>
|
||||
>答：
|
||||
> 答：
|
||||
>
|
||||
>1. OpenJDK 是开源的，开源意味着你可以对它根据你自己的需要进行修改、优化，比如 Alibaba 基于 OpenJDK 开发了 Dragonwell8：[https://github.com/alibaba/dragonwell8](https://github.com/alibaba/dragonwell8)
|
||||
> 1. OpenJDK 是开源的，开源意味着你可以对它根据你自己的需要进行修改、优化，比如 Alibaba 基于 OpenJDK 开发了 Dragonwell8：[https://github.com/alibaba/dragonwell8](https://github.com/alibaba/dragonwell8)
|
||||
>
|
||||
>2. OpenJDK 是商业免费的（这也是为什么通过 yum 包管理器上默认安装的 JDK 是 OpenJDK 而不是 Oracle JDK）。虽然 Oracle JDK 也是商业免费（比如 JDK 8），但并不是所有版本都是免费的。
|
||||
> 2. OpenJDK 是商业免费的（这也是为什么通过 yum 包管理器上默认安装的 JDK 是 OpenJDK 而不是 Oracle JDK）。虽然 Oracle JDK 也是商业免费（比如 JDK 8），但并不是所有版本都是免费的。
|
||||
>
|
||||
>3. OpenJDK 更新频率更快。Oracle JDK 一般是每 6 个月发布一个新版本，而 OpenJDK 一般是每 3 个月发布一个新版本。（现在你知道为啥 Oracle JDK 更稳定了吧，先在 OpenJDK 试试水，把大部分问题都解决掉了才在 Oracle JDK 上发布）
|
||||
> 3. OpenJDK 更新频率更快。Oracle JDK 一般是每 6 个月发布一个新版本，而 OpenJDK 一般是每 3 个月发布一个新版本。（现在你知道为啥 Oracle JDK 更稳定了吧，先在 OpenJDK 试试水，把大部分问题都解决掉了才在 Oracle JDK 上发布）
|
||||
>
|
||||
> 基于以上这些原因，OpenJDK 还是有存在的必要的！
|
||||
|
||||
|
||||
|
||||
|
||||
🌈 拓展一下：
|
||||
|
||||
@ -148,13 +148,15 @@ AOT 可以提前编译节省启动时间，那为什么不全部使用这种编
|
||||
|
||||
Java 中的注释有三种：
|
||||
|
||||
1. 单行注释
|
||||
1. **单行注释** ：通常用于解释方法内某单行代码的作用。
|
||||
|
||||
2. 多行注释
|
||||
2. **多行注释** ：通常用于解释一段代码的作用。
|
||||
|
||||
3. 文档注释
|
||||
3. **文档注释** ：通常用于生成 Java 开发文档。
|
||||
|
||||
用的比较多的还是单行注释和文档注释，多行注释在实际开发中使用的相对较少。
|
||||
|
||||
|
||||
|
||||
在我们编写代码的时候，如果代码量比较少，我们自己或者团队其他成员还可以很轻易地看懂代码，但是当项目结构一旦复杂起来，我们就需要用到注释了。注释并不会执行(编译器在编译代码之前会把代码中的所有注释抹掉,字节码中不保留注释)，是我们程序员写给自己看的，注释是你的代码说明书，能够帮助看代码的人快速地理清代码之间的逻辑关系。因此，在写程序的时候随手加上注释是一个非常好的习惯。
|
||||
|
||||
@ -179,14 +181,6 @@ Java 中的注释有三种：
|
||||
> if (employee.isEligibleForFullBenefits())
|
||||
> ```
|
||||
|
||||
### 字符型常量和字符串常量的区别?
|
||||
|
||||
1. **形式** : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符。
|
||||
2. **含义** : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
|
||||
3. **占内存大小** ： 字符常量只占 2 个字节; 字符串常量占若干个字节。
|
||||
|
||||
(**注意： `char` 在 Java 中占两个字节**)
|
||||
|
||||
### 标识符和关键字的区别是什么？
|
||||
|
||||
在我们编写程序的时候，需要大量地为程序、类、变量、方法等取名字，于是就有了 **标识符** 。简单来说， **标识符就是一个名字** 。
|
||||
@ -196,7 +190,7 @@ Java 中的注释有三种：
|
||||
### Java 语言关键字有哪些？
|
||||
|
||||
| 分类 | 关键字 | | | | | | |
|
||||
| :------------------- | -------- |-------- | -------- | -------- | --------| --------| -------- |
|
||||
| :------------------- | -------- | ---------- | -------- | ------------ | ---------- | --------- | ------ |
|
||||
| 访问控制 | private | protected | public | | | | |
|
||||
| 类，方法和变量修饰符 | abstract | class | extends | final | implements | interface | native |
|
||||
| | new | static | strictfp | synchronized | transient | volatile | enum |
|
||||
@ -217,9 +211,9 @@ Java 中的注释有三种：
|
||||
> - 在类，方法和变量修饰符中，从 JDK8 开始引入了默认方法，可以使用 `default` 关键字来定义一个方法的默认实现。
|
||||
> - 在访问控制中，如果一个方法前没有任何修饰符，则默认会有一个修饰符 `default`，但是这个修饰符加上了就会报错。
|
||||
|
||||
⚠️注意 ：虽然 `true`, `false`, 和 `null` 看起来像关键字但实际上他们是字面值，同时你也不可以作为标识符来使用。
|
||||
⚠️ 注意 ：虽然 `true`, `false`, 和 `null` 看起来像关键字但实际上他们是字面值，同时你也不可以作为标识符来使用。
|
||||
|
||||
官方文档：[https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html)
|
||||
官方文档：[https://docs.oracle.com/javase/tutorial/java/nutsandbolts/\_keywords.html](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html)
|
||||
|
||||
### 自增自减运算符
|
||||
|
||||
@ -281,6 +275,29 @@ xixi
|
||||
haha
|
||||
```
|
||||
|
||||
### 变量
|
||||
|
||||
#### 成员变量与局部变量的区别？
|
||||
|
||||
- **语法形式** ：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 `public`,`private`,`static` 等修饰符所修饰，而局部变量不能被访问控制修饰符及 `static` 所修饰；但是，成员变量和局部变量都能被 `final` 所修饰。
|
||||
- **存储方式** ：从变量在内存中的存储方式来看,如果成员变量是使用 `static` 修饰的，那么这个成员变量是属于类的，如果没有使用 `static` 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
|
||||
- **生存时间** ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
|
||||
- **默认值** ：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
||||
|
||||
#### 静态变量有什么作用？
|
||||
|
||||
静态变量可以被类的所有实例共享。无论一个类创建了多少个对象，它们都共享同一份静态变量。
|
||||
|
||||
通常情况下，静态变量会被 `final` 关键字修饰成为常量。
|
||||
|
||||
#### 字符型常量和字符串常量的区别?
|
||||
|
||||
1. **形式** : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符。
|
||||
2. **含义** : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
|
||||
3. **占内存大小** ： 字符常量只占 2 个字节; 字符串常量占若干个字节。
|
||||
|
||||
(**注意： `char` 在 Java 中占两个字节**)
|
||||
|
||||
### 方法
|
||||
|
||||
#### 什么是方法的返回值?方法有哪几种类型？
|
||||
@ -370,7 +387,7 @@ public class Person {
|
||||
|
||||
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制。
|
||||
|
||||
#### 重载和重写的区别
|
||||
#### 重载和重写有什么区别？
|
||||
|
||||
> 重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
|
||||
>
|
||||
@ -406,7 +423,7 @@ public class Person {
|
||||
综上：**重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。**
|
||||
|
||||
| 区别点 | 重载方法 | 重写方法 |
|
||||
| :--------- | :------- | :--------------------------------------------------------------- |
|
||||
| :--------- | :------- | :----------------------------------------------------------- |
|
||||
| 发生范围 | 同一个类 | 子类 |
|
||||
| 参数列表 | 必须修改 | 一定不能修改 |
|
||||
| 返回类型 | 可修改 | 子类方法返回值类型应比父类方法返回值类型更小或相等 |
|
||||
@ -450,7 +467,7 @@ public class SuperSuperMan extends SuperMan {
|
||||
}
|
||||
```
|
||||
|
||||
### 什么是可变长参数？
|
||||
#### 什么是可变长参数？
|
||||
|
||||
从 Java5 开始，Java 支持定义可变长参数，所谓可变长参数就是允许在调用方法时传入不定长度的参数。就比如下面的这个 `printVariable` 方法就可以接受 0 个或者多个参数。
|
||||
|
||||
@ -574,7 +591,7 @@ Java 中有 8 种基本数据类型，分别为：
|
||||
|
||||
**为什么说是几乎所有对象实例呢？** 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存
|
||||
|
||||
⚠️注意 ： **基本数据类型存放在栈中是一个常见的误区！** 基本数据类型的成员变量如果没有被 `static` 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。
|
||||
⚠️ 注意 ： **基本数据类型存放在栈中是一个常见的误区！** 基本数据类型的成员变量如果没有被 `static` 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。
|
||||
|
||||
```java
|
||||
class BasicTypeVar{
|
||||
@ -734,6 +751,72 @@ private static long sum() {
|
||||
}
|
||||
```
|
||||
|
||||
### 为什么浮点数运算的时候会有精度丢失的风险？
|
||||
|
||||
浮点数运算精度丢失代码演示：
|
||||
|
||||
```java
|
||||
float a = 2.0f - 1.9f;
|
||||
float b = 1.8f - 1.7f;
|
||||
System.out.println(a);// 0.100000024
|
||||
System.out.println(b);// 0.099999905
|
||||
System.out.println(a == b);// false
|
||||
```
|
||||
|
||||
为什么会出现这个问题呢？
|
||||
|
||||
这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。
|
||||
|
||||
就比如说十进制下的 0.2 就没办法精确转换成二进制小数：
|
||||
|
||||
```java
|
||||
// 0.2 转换为二进制数的过程为，不断乘以 2，直到不存在小数为止，
|
||||
// 在这个计算过程中，得到的整数部分从上到下排列就是二进制的结果。
|
||||
0.2 * 2 = 0.4 -> 0
|
||||
0.4 * 2 = 0.8 -> 0
|
||||
0.8 * 2 = 1.6 -> 1
|
||||
0.6 * 2 = 1.2 -> 1
|
||||
0.2 * 2 = 0.4 -> 0（发生循环）
|
||||
...
|
||||
```
|
||||
|
||||
关于浮点数的更多内容，建议看一下[计算机系统基础（四）浮点数](http://kaito-kidd.com/2018/08/08/computer-system-float-point/)这篇文章。
|
||||
|
||||
### 如何解决浮点数运算的精度丢失问题？
|
||||
|
||||
`BigDecimal` 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 `BigDecimal` 来做的。
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1.0");
|
||||
BigDecimal b = new BigDecimal("0.9");
|
||||
BigDecimal c = new BigDecimal("0.8");
|
||||
|
||||
BigDecimal x = a.subtract(b);
|
||||
BigDecimal y = b.subtract(c);
|
||||
|
||||
System.out.println(x); /* 0.1 */
|
||||
System.out.println(y); /* 0.1 */
|
||||
System.out.println(Objects.equals(x, y)); /* true */
|
||||
```
|
||||
|
||||
关于 `BigDecimal` 的详细介绍，可以看看我写的这篇文章：[BigDecimal 详解](./bigdecimal.md)。
|
||||
|
||||
### 超过 long 整型的数据应该如何表示？
|
||||
|
||||
基本数值类型都有一个表达范围，如果超过这个范围就会有数值溢出的风险。
|
||||
|
||||
在 Java 中，64 位 long 整型是最大的整数类型。
|
||||
|
||||
```java
|
||||
long l = Long.MAX_VALUE;
|
||||
System.out.println(l + 1); // -9223372036854775808
|
||||
System.out.println(l + 1 == Long.MIN_VALUE); // true
|
||||
```
|
||||
|
||||
`BigInteger` 内部使用 `int[]` 数组来存储任意大小的整形数据。
|
||||
|
||||
相对于常规整数类型的运算来说，`BigInteger` 运算的效率会相对较低。
|
||||
|
||||
## 参考
|
||||
|
||||
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
|
||||
|
||||
@ -18,13 +18,6 @@ tag:
|
||||
|
||||
相关 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431)
|
||||
|
||||
### 成员变量与局部变量的区别
|
||||
|
||||
- **语法形式** ：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 `public`,`private`,`static` 等修饰符所修饰，而局部变量不能被访问控制修饰符及 `static` 所修饰；但是，成员变量和局部变量都能被 `final` 所修饰。
|
||||
- **存储方式** ：从变量在内存中的存储方式来看,如果成员变量是使用 `static` 修饰的，那么这个成员变量是属于类的，如果没有使用 `static` 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
|
||||
- **生存时间** ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
|
||||
- **默认值** ：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
||||
|
||||
### 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
||||
|
||||
new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user