Course 模块 1 - Lecture: 详细包装器类

1.`Integer`类

Integer另一个好处是它是一个类，这意味着它可以有字段和方法。而且，当然，它有它们。很多——几十个。在这里，我们将考虑最基本的。

该类Integer有两个字段，包含该int类型的最大可能值和最小值：

场地	描述
`Integer.MAX_VALUE`	`int`类型的最大可能值
`Integer.MIN_VALUE`	`int`类型的最小可能值

有时您希望将最小或最大的可能int值分配给变量。为了避免用难以理解的常量弄乱你的代码，你可以把它写得非常清楚，如下所示：

代码	描述
`int min = Integer.MIN_VALUE;`	`min == 0x80000000`

该类Integer还有一些有趣的方法。他们来了：

方法	描述
`String Integer.toHexString(int)`	返回一个字符串，它是数字的十六进制表示
`String Integer.toBinaryString(int)`	返回一个字符串，它是数字的二进制表示
`String Integer.toOctalString(int)`	返回一个字符串，它是数字的八进制表示
`Integer Integer.valueOf(int i)`	包装传入`int`的`Integer`对象
`Integer Integer.parseInt(String)`	返回从传递的字符串中获得的数字

您之前遇到过静态Integer.parseInt()方法。让我们回顾一下它是如何工作的：

int name = Integer.parseInt(string);

如果将包含数字（仅数字）的字符串传递给该parseInt()方法，它将解析该字符串并返回它包含的数字。

其余的方法也很有用。例如，其中一些可以将传递的数字转换为包含该数字的二进制、八进制或十六进制表示形式的字符串。

2.`Double`类

一般来说，Double类与类相似Integer，只是它包装了一个double而不是一个int. 它还具有我们会感兴趣的字段和方法。考虑其中的一些：

该Double课程有六个有趣的领域：

场地	描述
`double Double.NEGATIVE_INFINITY`	负无穷大
`double Double.POSITIVE_INFINITY`	正无穷大
`int Double.MIN_EXPONENT`	最小可能指数 (2 ^x )
`int Double.MAX_EXPONENT`	最大可能指数 (2 ^x )
`double Double.MIN_VALUE`	`double`类型的最小可能值
`double Double.MAX_VALUE`	`double`类型的最大可能值

无穷

如果你除以-1.0，0.0你会得到负无穷大。如果除以1.0，0.0您将得到正无穷大。您不仅可以将 a 除以double零，还可以使用它来存储这些操作的结果。

的指数double

理解指数很容易。在内部，双精度数由尾数和指数组成。但是这里指数的值不是，而是。因此，如果指数增加，则数字的总值将增加一倍。10^x2^x1

MIN_EXPONENT == -1024, 这意味着, 这大约等于2^-102410^-308

当然，这个Double类有一些有趣的方法：

方法	描述
`String Double.toHexString(double)`	返回一个字符串，它是数字的十六进制表示
`boolean Double.isInfinite(double)`	检查传递的数字是否为无穷大。
`boolean Double.isNaN(double)`	检查传递的号码是否为`NaN`
`Double Double.valueOf(double)`	包装传入`double`的`Double`对象
`Double Double.parseDouble(String)`	返回从传递的字符串中获得的数字

有趣的是，如果传递的数字是正无穷大或负无穷大，有一种isInfinite()方法会返回。true

该isNaN()方法类似——它检查传递的数字是否为NaN（Not-a-Number，一个表示未定义值的特殊常量）。

3.`Character`类

这个Character类之所以有趣，主要是因为它有大量的静态实用方法，可以让您检查字符是否属于不同的类别。

例子

方法	描述
`Character.isAlphabetic(int)`	检查字符是否为字母字符
`Character.isLetter(char)`	检查字符是否为字母
`Character.isDigit(char)`	检查字符是否为数字
`Character.isSpaceChar(char)`	检查字符是否为空格、换行符或分页符（代码：12、13、14）
`Character.isWhitespace(char)`	检查字符是否为空白：空格、制表符等。
`Character.isLowerCase(char)`	检查字符是否为小写
`Character.isUpperCase(char)`	检查字符是否为大写

`Character.toLowerCase(char)`	将字符转换为小写
`Character.toUpperCase(char)`	将字符转换为大写

这些方法的一个特点是它们适用于所有已知的字母表：阿拉伯数字被归类为数字等。

4.`Boolean`类

类型Boolean实际上与类型相同boolean。差异很小。

下面我们展示了该类的简化版本Boolean：

代码描述

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

常量：TRUEè FALSE

Variable

Booleanclass constructor

方法返回内部变量的值

This static method 转换true为TRUE和falseto FALSE。

该Boolean类型有两个常量（两个字段）：

类的常量	对应布尔类型	描述
`Boolean.TRUE`	`true`	真的
`Boolean.FALSE`	`false`	错误的

您可以像使用类型一样使用它们boolean：

代码	笔记
`if (Boolean.TRUE) { }`	该类`Boolean`是唯一可以在条件内编写的类
`Boolean a = Boolean.TRUE; boolean b = Boolean.TRUE; boolean c = true;`	所有三个变量都等于`true`/`TRUE`
`Boolean a = Boolean.TRUE; Boolean b = Boolean.TRUE; if (a == b)`	可以同时使用`equals`和比较常量`==` 这也可以。

自动装箱在这里效果很好。这意味着您可以像使用类型一样使用此类型boolean——没有需要注意的陷阱。

它是如何写的怎么运行的

Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

boolean这里是和类型的比较Boolean：

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

如果你真的需要一个独立的Boolean对象，那么你需要显式地创建它：

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

再举一个例子，我们将使用Booleanan 的内部if：

代码	笔记
`Boolean less = (2 < 3); if (less) { ... }`	这将编译和工作

这将编译，但它不会工作！

代码	笔记
`Boolean less = null; if (less) { ... }`	错误。这一行会抛出异常

5. 自动装箱时缓存值

有一些与整数包装器类型相关的陷阱。

如您所知，如果我们比较 anint和 an Integer， theInteger将转换为 an int：

它是如何写的	怎么运行的
`int a = 5; Integer b = 5; if (a == b) { ... }`	`int a = 5; Integer b = Integer.valueOf(5); if (a == b.intValue()) { ... }`

如果将两个Integer对象相互比较，它们不会转换为ints：

代码	控制台输出
`Integer a = 500; Integer b = 500; int c = 500; System.out.println(a == b); // Compared by reference System.out.println(a == c); System.out.println(b == c);`	`false true true`

a == cand , but ，因为当我们比较and时，我们是在比较引用。这基本上是我们所期望的。b == ca != bab

惊喜

但是如果我们替换500为100，那么我们会得到完全不同的结果：

代码	控制台输出
`Integer a = 100; Integer b = 100; int c = 100; System.out.println(a == b); // Compared by reference System.out.println(a == c); System.out.println(b == c);`	`true true true`

这里的问题是在自动装箱期间并不总是实际创建新Integer对象。-128通过inclusive缓存对象的值127。

该类Integer有一个存储对象的隐藏数组：Integer(-128), Integer(-127), ... Integer(126),Integer(127)

如果你写Integer x = 128，那么自动装箱过程会创建一个新对象，但如果你写Integer x = 127，那么自动装箱过程会从缓存（从数组）中检索现有对象。

如果您不希望该Integer对象来自缓存，则必须通过以下方式显式创建它：Integer x = new Integer(127);

所有包装器类型都有这样的缓存：Integer, Long, Byte, Short, Boolean。对于Boolean类型来说，它TRUE和FALSE值都是常量，所以本质上也是缓存的。

详细包装器类

1.Integer类

2.Double类

3.Character类

4.Boolean类

5. 自动装箱时缓存值

1.`Integer`类

2.`Double`类

3.`Character`类

4.`Boolean`类