Java基础（补充）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

为什么 Java 中只有值传递？

开始之前，我们先来搞懂下面这两个概念：

形参&实参
值传递&引用传递

形参&实参

方法的定义可能会用到参数（有参的方法），参数在程序语言中分为：

实参（实际参数） ：用于传递给函数/方法的参数，必须有确定的值。
形参（形式参数） ：用于定义函数/方法，接收实参，不需要有确定的值。

String hello = "Hello!";

// hello 为实参

sayHello(hello);

// str 为形参

void sayHello(String str) {

    System.out.println(str);

}

值传递&引用传递

程序设计语言将实参传递给方法（或函数）的方式分为两种：

值传递 ：方法接收的是实参值的拷贝，会创建副本。
引用传递 ：方法接收的直接是实参所引用的对象在堆中的地址，不会创建副本，对形参的修改将影响到实参。

很多程序设计语言（比如 C++、 Pascal )提供了两种参数传递的方式，不过，在 Java 中只有值传递。

为什么 Java 只有值传递？

为什么说 Java 只有值传递呢？ 不需要太多废话，我通过 3 个例子来给大家证明。

案例1：传递基本类型参数

代码：

public static void main(String[] args) {

    int num1 = 10;

    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);

    System.out.println("num2 = " + num2);

}

public static void swap(int a, int b) {

    int temp = a;

    a = b;

    b = temp;

    System.out.println("a = " + a);

    System.out.println("b = " + b);

}

输出：

a = 20

b = 10

num1 = 10

num2 = 20

解析：

在 swap() 方法中， a 、 b 的值进行交换，并不会影响到 num1 、 num2 。因为， a 、 b 的值，只是从 num1 、 num2 的复制过来的。也就是说，a、b 相当于 num1 、 num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看案例2。

案例2：传递引用类型参数1

代码：

    public static void main(String[] args) {

      int[] arr = { 1, 2, 3, 4, 5 };

      System.out.println(arr[0]);

      change(arr);

      System.out.println(arr[0]);

    }

    public static void change(int[] array) {

      // 将数组的第一个元素变为0

      array[0] = 0;

    }

输出：

1

0

解析：

看了这个案例很多人肯定觉得 Java 对引用类型的参数采用的是引用传递。

实际上，并不是的，这里传递的还是值，不过，这个值是实参的地址罢了！

也就是说 change 方法的参数拷贝的是 arr （实参）的地址，因此，它和 arr 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。

为了更强有力地反驳 Java 对引用类型的参数采用的不是引用传递，我们再来看下面这个案例！

案例3 ：传递引用类型参数2

public class Person {

    private String name;

   // 省略构造函数、Getter&Setter方法

}

public static void main(String[] args) {

    Person xiaoZhang = new Person("小张");

    Person xiaoLi = new Person("小李");

    swap(xiaoZhang, xiaoLi);

    System.out.println("xiaoZhang:" + xiaoZhang.getName());

    System.out.println("xiaoLi:" + xiaoLi.getName());

}

public static void swap(Person person1, Person person2) {

    Person temp = person1;

    person1 = person2;

    person2 = temp;

    System.out.println("person1:" + person1.getName());

    System.out.println("person2:" + person2.getName());

}

输出:

person1:小李

person2:小张

xiaoZhang:小张

xiaoLi:小李

解析：

怎么回事？？？两个引用类型的形参互换并没有影响实参啊！

swap 方法的参数 person1 和 person2 只是拷贝的实参 xiaoZhang 和 xiaoLi 的地址。因此， person1 和 person2 的互换只是拷贝的两个地址的互换罢了，并不会影响到实参 xiaoZhang 和 xiaoLi 。

总结

Java 中将实参传递给方法（或函数）的方式是 值传递 ：

如果参数是基本类型的话，很简单，传递的就是基本类型的字面量值的拷贝，会创建副本。
如果参数是引用类型，传递的就是实参所引用的对象在堆中地址值的拷贝，同样也会创建副本。

I/O

思维导图

何为 I/O?

I/O（ I nput/ O utpu）即 输入／输出 。

我们先从计算机结构的角度来解读一下 I/O。

根据冯.诺依曼结构，计算机结构分为 5 大部分：运算器、控制器、存储器、输入设备、输出设备。

输入设备（比如键盘）和输出设备（比如显示器）都属于外部设备。网卡、硬盘这种既可以属于输入设备，也可以属于输出设备。

输入设备向计算机输入数据，输出设备接收计算机输出的数据。

从计算机结构的视角来看的话， I/O 描述了计算机系统与外部设备之间通信的过程。

我们再先从应用程序的角度来解读一下 I/O。

根据大学里学到的操作系统相关的知识：为了保证操作系统的稳定性和安全性，一个进程的地址空间划分为 用户空间（User space） 和 内核空间（Kernel space ） 。

像我们平常运行的应用程序都是运行在用户空间，只有内核空间才能进行系统态级别的资源有关的操作，比如文件管理、进程通信、内存管理等等。也就是说，我们想要进行 IO 操作，一定是要依赖内核空间的能力。

并且，用户空间的程序不能直接访问内核空间。

当想要执行 IO 操作时，由于没有执行这些操作的权限，只能发起系统调用请求操作系统帮忙完成。

因此，用户进程想要执行 IO 操作的话，必须通过 系统调用 来间接访问内核空间

我们在平常开发过程中接触最多的就是 磁盘 IO（读写文件） 和 网络 IO（网络请求和响应） 。

从应用程序的视角来看的话，我们的应用程序对操作系统的内核发起 IO 调用（系统调用），操作系统负责的内核执行具体的 IO 操作。也就是说，我们的应用程序实际上只是发起了 IO 操作的调用而已，具体 IO 的执行是由操作系统的内核来完成的。

当应用程序发起 I/O 调用后，会经历两个步骤：

内核等待 I/O 设备准备好数据
内核将数据从内核空间拷贝到用户空间。

有哪些常见的 IO 模型?

UNIX 系统下， IO 模型一共有 5 种： 同步阻塞 I/O 、 同步非阻塞 I/O 、 I/O 多路复用 、 信号驱动 I/O 和 异步 I/O 。

这也是我们经常提到的 5 种 IO 模型。

Java 中 3 种常见 IO 模型

BIO (Blocking I/O)

BIO 属于同步阻塞 IO 模型 。

同步阻塞 IO 模型中，应用程序发起 read 调用后，会一直阻塞，直到内核把数据拷贝到用户空间。

在客户端连接数量不高的情况下，是没问题的。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。

NIO (Non-blocking/New I/O)

Java 中的 NIO 于 Java 1.4 中引入，对应 java.nio 包，提供了 Channel , Selector ， Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它是支持面向缓冲的，基于通道的 I/O 操作方法。对于高负载、高并发的（网络）应用，应使用 NIO 。

Java 中的 NIO 可以看作是 I/O 多路复用模型 。也有很多人认为，Java 中的 NIO 属于同步非阻塞 IO 模型。

跟着我的思路往下看看，相信你会得到答案！

我们先来看看 同步非阻塞 IO 模型 。

同步非阻塞 IO 模型中，应用程序会一直发起 read 调用，等待数据从内核空间拷贝到用户空间的这段时间里，线程依然是阻塞的，直到在内核把数据拷贝到用户空间。

相比于同步阻塞 IO 模型，同步非阻塞 IO 模型确实有了很大改进。通过轮询操作，避免了一直阻塞。

但是，这种 IO 模型同样存在问题： 应用程序不断进行 I/O 系统调用轮询数据是否已经准备好的过程是十分消耗 CPU 资源的。

这个时候， I/O 多路复用模型 就上场了。

IO 多路复用模型中，线程首先发起 select 调用，询问内核数据是否准备就绪，等内核把数据准备好了，用户线程再发起 read 调用。read 调用的过程（数据从内核空间 -> 用户空间）还是阻塞的。

目前支持 IO 多路复用的系统调用，有 select，epoll 等等。select 系统调用，目前几乎在所有的操作系统上都有支持。

select 调用 ：内核提供的系统调用，它支持一次查询多个系统调用的可用状态。几乎所有的操作系统都支持。

epoll 调用 ：linux 2.6 内核，属于 select 调用的增强版本，优化了 IO 的执行效率。

IO 多路复用模型，通过减少无效的系统调用，减少了对 CPU 资源的消耗。

Java 中的 NIO ，有一个非常重要的 选择器 ( Selector ) 的概念，也可以被称为 多路复用器 。通过它，只需要一个线程便可以管理多个客户端连接。当客户端数据到了之后，才会为其服务。

AIO (Asynchronous I/O)

AIO 也就是 NIO 2。Java 7 中引入了 NIO 的改进版 NIO 2,它是异步 IO 模型。

异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

目前来说 AIO 的应用还不是很广泛。Netty 之前也尝试使用过 AIO，不过又放弃了。这是因为，Netty 使用了 AIO 之后，在 Linux 系统上的性能并没有多少提升。

最后，来一张图，简单总结一下 Java 中的 BIO、NIO、AIO。

BigDecimal 解决精度丢失问题

BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 BigDecimal 来做的。

纳尼，浮点数的运算竟然还会有精度丢失的风险吗？确实会！

示例代码：

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

为什么浮点数 float 或 double 运算的时候会有精度丢失的风险呢？

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。

就比如说十进制下的 0.2 就没办法精确转换成二进制小数：

// 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（发生循环）

...

关于浮点数的更多内容，建议看一下计算机系统基础（四）浮点数这篇文章。

BigDecimal 的用处

《阿里巴巴 Java 开发手册》中提到： 浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。

具体原因我们在上面已经详细介绍了，这里就不多提了，我们下面直接上实例：

实例：

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

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 常见方法

加减乘除

add 方法用于将两个 BigDecimal 对象相加， subtract 方法用于将两个 BigDecimal 对象相减。 multiply 方法用于将两个 BigDecimal 对象相乘， divide 方法用于将两个 BigDecimal 对象相除。

BigDecimal a = new BigDecimal("1.0");

BigDecimal b = new BigDecimal("0.9");

System.out.println(a.add(b));// 1.9

System.out.println(a.subtract(b));// 0.1

System.out.println(a.multiply(b));// 0.90

System.out.println(a.divide(b));// 无法除尽，抛出 ArithmeticException 异常

System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));// 1.11

这里需要注意的是，在我们使用 divide 方法的时候尽量使用 3 个参数版本，并且 RoundingMode 不要选择 UNNECESSARY ，否则很可能会遇到 ArithmeticException （无法除尽出现无限循环小数的时候），其中 scale 表示要保留几位小数， roundingMode 代表保留规则。

public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) {

    return divide(divisor, scale, roundingMode.oldMode);

}

保留规则非常多，这里列举几种:

public enum RoundingMode {

   // 2.5 -> 3 , 1.6 -> 2

   // -1.6 -> -2 , -2.5 -> -3

             UP(BigDecimal.ROUND_UP),

   // 2.5 -> 2 , 1.6 -> 1

   // -1.6 -> -1 , -2.5 -> -2

             DOWN(BigDecimal.ROUND_DOWN),

             // 2.5 -> 3 , 1.6 -> 2

   // -1.6 -> -1 , -2.5 -> -2

             CEILING(BigDecimal.ROUND_CEILING),

             // 2.5 -> 2 , 1.6 -> 1

   // -1.6 -> -2 , -2.5 -> -3

             FLOOR(BigDecimal.ROUND_FLOOR),

       // 2.5 -> 3 , 1.6 -> 2

   // -1.6 -> -2 , -2.5 -> -3

             HALF_UP(BigDecimal.ROUND_HALF_UP),

   //......

}

大小比较

a.compareTo(b) : 返回 -1 表示 a 小于 b ，0 表示 a 等于 b ， 1 表示 a 大于 b 。

BigDecimal a = new BigDecimal("1.0");

BigDecimal b = new BigDecimal("0.9");

System.out.println(a.compareTo(b));// 1

保留几位小数

通过 setScale 方法设置保留几位小数以及保留规则。保留规则有挺多种，不需要记，IDEA 会提示。

BigDecimal m = new BigDecimal("1.255433");

BigDecimal n = m.setScale(3,RoundingMode.HALF_DOWN);

System.out.println(n);// 1.255

BigDecimal 的使用注意事项

注意：我们在使用 BigDecimal 时，为了防止精度丢失，推荐使用它的 BigDecimal(String val) 构造方法或者 BigDecimal.valueOf(double val) 静态方法来创建对象。

《阿里巴巴 Java 开发手册》对这部分内容也有提到，如下图所示。

BigDecimal 工具类分享

网上有一个使用人数比较多的 BigDecimal 工具类，提供了多个静态方法来简化 BigDecimal 的操作。

我对其进行了简单改进，分享一下源码：

import java.math.BigDecimal;

import java.math.RoundingMode;

/**

 * 简化BigDecimal计算的小工具类

 */

public class BigDecimalUtil {

    /**

     * 默认除法运算精度

     */

    private static final int DEF_DIV_SCALE = 10;

    private BigDecimalUtil() {

    }

    /**

     * 提供精确的加法运算。

     *

     * @param v1 被加数

     * @param v2 加数

     * @return 两个参数的和

     */

    public static double add(double v1, double v2) {

        BigDecimal b1 = BigDecimal.valueOf(v1);

        BigDecimal b2 = BigDecimal.valueOf(v2);

        return b1.add(b2).doubleValue();

    }

    /**

     * 提供精确的减法运算。

     *

     * @param v1 被减数

     * @param v2 减数

     * @return 两个参数的差

     */

    public static double subtract(double v1, double v2) {

        BigDecimal b1 = BigDecimal.valueOf(v1);

        BigDecimal b2 = BigDecimal.valueOf(v2);

        return b1.subtract(b2).doubleValue();

    }

    /**

     * 提供精确的乘法运算。

     *

     * @param v1 被乘数

     * @param v2 乘数

     * @return 两个参数的积

     */

    public static double multiply(double v1, double v2) {

        BigDecimal b1 = BigDecimal.valueOf(v1);

        BigDecimal b2 = BigDecimal.valueOf(v2);

        return b1.multiply(b2).doubleValue();

    }

    /**

     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到

     * 小数点以后10位，以后的数字四舍五入。

     *

     * @param v1 被除数

     * @param v2 除数

     * @return 两个参数的商

     */

    public static double divide(double v1, double v2) {

        return divide(v1, v2, DEF_DIV_SCALE);

    }

    /**

     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指

     * 定精度，以后的数字四舍五入。

     *

     * @param v1    被除数

     * @param v2    除数

     * @param scale 表示表示需要精确到小数点以后几位。

     * @return 两个参数的商

     */

    public static double divide(double v1, double v2, int scale) {

        if (scale < 0) {

            throw new IllegalArgumentException(

                    "The scale must be a positive integer or zero");

        }

        BigDecimal b1 = BigDecimal.valueOf(v1);

        BigDecimal b2 = BigDecimal.valueOf(v2);

        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();

    }

    /**

     * 提供精确的小数位四舍五入处理。

     *

     * @param v     需要四舍五入的数字

     * @param scale 小数点后保留几位

     * @return 四舍五入后的结果

     */

    public static double round(double v, int scale) {

        if (scale < 0) {

            throw new IllegalArgumentException(

                    "The scale must be a positive integer or zero");

        }

        BigDecimal b = BigDecimal.valueOf(v);

        BigDecimal one = new BigDecimal("1");

        return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();

    }

    /**

     * 提供精确的类型转换(Float)

     *

     * @param v 需要被转换的数字

     * @return 返回转换结果

     */

    public static float convertToFloat(double v) {

        BigDecimal b = new BigDecimal(v);

        return b.floatValue();

    }

    /**

     * 提供精确的类型转换(Int)不进行四舍五入

     *

     * @param v 需要被转换的数字

     * @return 返回转换结果

     */

    public static int convertsToInt(double v) {

        BigDecimal b = new BigDecimal(v);

        return b.intValue();

    }

    /**

     * 提供精确的类型转换(Long)

     *

     * @param v 需要被转换的数字

     * @return 返回转换结果

     */

    public static long convertsToLong(double v) {

        BigDecimal b = new BigDecimal(v);

        return b.longValue();

    }

    /**

     * 返回两个数中大的一个值

     *

     * @param v1 需要被对比的第一个数

     * @param v2 需要被对比的第二个数

     * @return 返回两个数中大的一个值

     */

    public static double returnMax(double v1, double v2) {

        BigDecimal b1 = new BigDecimal(v1);

        BigDecimal b2 = new BigDecimal(v2);

        return b1.max(b2).doubleValue();

    }

    /**

     * 返回两个数中小的一个值

     *

     * @param v1 需要被对比的第一个数

     * @param v2 需要被对比的第二个数

     * @return 返回两个数中小的一个值

     */

    public static double returnMin(double v1, double v2) {

        BigDecimal b1 = new BigDecimal(v1);

        BigDecimal b2 = new BigDecimal(v2);

        return b1.min(b2).doubleValue();

    }

    /**

     * 精确对比两个数字

     *

     * @param v1 需要被对比的第一个数

     * @param v2 需要被对比的第二个数

     * @return 如果两个数一样则返回0，如果第一个数比第二个数大则返回1，反之返回-1

     */

    public static int compareTo(double v1, double v2) {

        BigDecimal b1 = BigDecimal.valueOf(v1);

        BigDecimal b2 = BigDecimal.valueOf(v2);

        return b1.compareTo(b2);

    }

}

总结

浮点数没有办法用二进制精确表示，因此存在精度丢失的风险。

不过，Java 提供了 BigDecimal 来操作浮点数。 BigDecimal 的实现利用到了 BigInteger （用来操作大整数）, 所不同的是 BigDecimal 加入了小数位的概念。

参考

值传递

《Java 核心技术卷 Ⅰ》基础知识第十版第四章 4.5 小节
Java 到底是值传递还是引用传递？ - Hollis的回答 - 知乎

I/O

《深入拆解 Tomcat & Jetty》
如何完成一次 IO：https://llc687.top/post/如何完成一次-io/
程序员应该这样理解 IO：https://www.jianshu.com/p/fa7bdc4f3de7
10 分钟看懂， Java NIO 底层原理：https://www.cnblogs.com/crazymakercircle/p/10225159.html
IO 模型知多少 | 理论篇：https://www.cnblogs.com/sheng-jie/p/how-much-you-know-about-io-models.html
《UNIX 网络编程卷 1；套接字联网 API 》6.2 节 IO 模型

正文

为什么 Java 中只有值传递？

形参&实参

值传递&引用传递

为什么 Java 只有值传递？

案例1：传递基本类型参数

案例2：传递引用类型参数1

案例3 ：传递引用类型参数2

总结

I/O

思维导图

何为 I/O?

有哪些常见的 IO 模型?

Java 中 3 种常见 IO 模型

BIO (Blocking I/O)

NIO (Non-blocking/New I/O)

AIO (Asynchronous I/O)

BigDecimal 解决精度丢失问题

BigDecimal 的用处

BigDecimal 常见方法

加减乘除

大小比较

保留几位小数

BigDecimal 的使用注意事项

BigDecimal 工具类分享

总结

参考

值传递

I/O

面试题

为什么 Java 中只有值传递？

谈谈你对IO的理解？BIO、NIO、AIO？

为啥有时会出现 4.0 - 3.6 = 0.40000001 这种现象？

相关阅读

c语言浮点数输出，c语言浮点数输出咋不补充0

macos10.13补充更新的简单介绍

c语言找补程序，c语言程序补充题

javascript补充说明书，js补全queue方法

补充面向对象，面向对象缺陷

excel怎么补充列序号，excel怎么补充数值

sqlserver补充空格，sqlserver 补齐字符串

sqlserver左补充0，sql左填充

目录[+]

为什么 Java 中只有值传递？

形参&实参

值传递&引用传递

为什么 Java 只有值传递？

案例1：传递基本类型参数

案例2：传递引用类型参数1

案例3 ：传递引用类型参数2

总结

I/O 思维导图

何为 I/O?

有哪些常见的 IO 模型?

Java 中 3 种常见 IO 模型

BIO (Blocking I/O)

NIO (Non-blocking/New I/O)

AIO (Asynchronous I/O)

BigDecimal 解决精度丢失问题

BigDecimal 的用处

BigDecimal 常见方法

加减乘除

大小比较

保留几位小数

BigDecimal 的使用注意事项

BigDecimal 工具类分享

总结

参考

值传递

I/O

面试题 为什么 Java 中只有值传递？ 谈谈你对IO的理解？BIO、NIO、AIO？ 为啥有时会出现 4.0 - 3.6 = 0.40000001 这种现象？

相关阅读

c语言浮点数输出，c语言浮点数输出咋不补充0

macos10.13补充更新的简单介绍

c语言找补程序，c语言程序补充题

javascript补充说明书，js补全queue方法

补充面向对象，面向对象缺陷

excel怎么补充列序号，excel怎么补充数值

sqlserver补充空格，sqlserver 补齐字符串

sqlserver左补充0，sql左填充

目录[+]

I/O

思维导图

面试题

为什么 Java 中只有值传递？

谈谈你对IO的理解？BIO、NIO、AIO？

为啥有时会出现 4.0 - 3.6 = 0.40000001 这种现象？