java之进阶语法（System类、StringBuilder及包装类）

最新推荐文章于 2023-03-05 15:21:55 发布

志行千里者

最新推荐文章于 2023-03-05 15:21:55 发布

阅读量125

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/airconan/article/details/114393784

版权

java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

一、System类

java.lang.System 类包含一些有用的类字段和方法，可以获取与系统相关的信息或是系统级操作。它不能被实例化。
在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

// System类常用的方法有两个，分别为：
// public static long currentTimeMillis():返回以毫秒为单位的当前时间，用来测试程序的效率
// public static void arraycopy(Object src, int srcPos, Object dest, int desPos, int length):将数组中指定的数据拷贝到另一个数组中
int[] src = {1,2,3};
int[] dest = {6,7,8,9,10}
System.arraycopy(0,dest,0,3);

字段摘要如下：

`tatic PrintStream`	`err` “标准”错误输出流。
`static InputStream`	`in` “标准”输入流。
`static PrintStream`	`out` “标准”输出流。

方法摘要如下：

`static void`	`arraycopy(Object src, int srcPos,Object dest, int destPos, int length)` 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
`static String`	`clearProperty(String key)` 移除指定键指示的系统属性。
`static Console`	`console()` 返回与当前 Java 虚拟机关联的唯一 `Console` 对象（如果有）。
`static long`	`currentTimeMillis()` 返回以毫秒为单位的当前时间。
`static void`	`exit(int status)` 终止当前正在运行的 Java 虚拟机。
`static void`	`gc()` 运行垃圾回收器。
`static Map<String,String>`	`getenv()` 返回一个不能修改的当前系统环境的字符串映射视图。
`static String`	`getenv(String name)` 获取指定的环境变量值。
`static Properties`	`getProperties()` 确定当前的系统属性。
`static String`	`getProperty(String key)` 获取指定键指示的系统属性。
`static String`	`getProperty(String key, String def)` 获取用指定键描述的系统属性。
`static SecurityManager`	`getSecurityManager()` 获取系统安全接口。
`static int`	`identityHashCode(Object x)` 返回给定对象的哈希码，该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()。
`static Channel`	`inheritedChannel()` 返回从创建此 Java 虚拟机的实体中继承的信道。
`static void`	`load(String filename)` 从作为动态库的本地文件系统中以指定的文件名加载代码文件。
`static void`	`loadLibrary(String libname)` 加载由 `libname` 参数指定的系统库。
`static String`	`mapLibraryName(String libname)` 将一个库名称映射到特定于平台的、表示本机库的字符串中。
`static long`	`nanoTime()` 返回最准确的可用系统计时器的当前值，以毫微秒为单位。
`static void`	`runFinalization()` 运行处于挂起终止状态的所有对象的终止方法。
`static void`	`runFinalizersOnExit(boolean value)` 已过时。该方法具有固有的不安全性。它可能对正在使用的对象调用终结方法，而其他线程同时正在操作这些对象，从而导致不正确的行为或死锁。
`static void`	`setErr(PrintStream err)` 重新分配“标准”错误输出流。
`static void`	`setIn(InputStream in)` 重新分配“标准”输入流。
`static void`	`setOut(PrintStream out)` 重新分配“标准”输出流。
`static void`	`setProperties(Properties props)` 将系统属性设置为 `Properties` 参数。
`static String`	`setProperty(String key, String value)` 设置指定键指示的系统属性。
`static void`	`setSecurityManager(SecurityManager s)` 设置系统安全性。

二、java.lang.StringBuilder类

1.概述

String类：字符串是常量，他们的值在创建之后不能更改，字符串的底层是一个被final修饰的数组，不能改变，是一个常量。如下例：

String s = "a"+"b"+"c";
上式在内存中会产生5个字符串，即"a" "b" "c" "a+b" "a+b+c"

而StingBuilder是字符串缓冲区（可以看成是长度可变的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度。byte[] value = new byte[16];StringBuilder在内存中始终是一个数组，占用空间少，效率高。如果超出了StringBuilder的容量，会自动的扩容一倍。
StringBuilder是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。
例如，如果 z 引用一个当前内容为 "start" 的字符串的生成器对象，则该方法调用 z.append("le") 将使字符串生成器包含 "startle"，而 z.insert(4, "le") 将更改字符串生成器，使之包含 "starlet"。
通常，如果 sb 引用 StringBuilder 的实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。每个字符串生成器都有一定的容量。只要字符串生成器所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区。如果内部缓冲区溢出，则此容量自动增大。
将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。

2.构造方法

StringBuilder()
构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

StringBuilder(CharSequence seq)
构造一个字符串生成器，它包含与指定的 CharSequence 相同的字符。

StringBuilder(int capacity)
构造一个不带任何字符的字符串生成器，其初始容量由 capacity 参数指定。

StringBuilder(String str)
构造一个字符串生成器，并初始化为指定的字符串内容。

3.常用方法

`StringBuilder`	`append(boolean b)` 将 `boolean` 参数的字符串表示形式追加到序列。
`StringBuilder`	`append(char c)` 将 `char` 参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(char[] str)` 将 `char` 数组参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(char[] str, int offset, int len)` 将 `char` 数组参数的子数组的字符串表示形式追加到此序列。
`StringBuilder`	`append(CharSequence s)` 向此 Appendable 追加到指定的字符序列。
`StringBuilder`	`append(CharSequence s, int start, int end)` 将指定 `CharSequence` 的子序列追加到此序列。
`StringBuilder`	`append(double d)` 将 `double` 参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(float f)` 将 `float` 参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(int i)` 将 `int` 参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(long lng)` 将 `long` 参数的字符串表示形式追加到此序列。
`StringBuilder`	`append(Object obj)` 追加 `Object` 参数的字符串表示形式。
`StringBuilder`	`append(String str)` 将指定的字符串追加到此字符序列。
`StringBuilder`	`append(StringBuffer sb)` 将指定的 StringBuffer 追加到此序列。
`StringBuilder`	`appendCodePoint(int codePoint)` 将 `codePoint` 参数的字符串表示形式追加到此序列。
`int`	`capacity()` 返回当前容量。
`char`	`charAt(int index)` 返回此序列中指定索引处的 `char` 值。
`int`	`codePointAt(int index)` 返回指定索引处的字符（统一代码点）。
`int`	`codePointBefore(int index)` 返回指定索引前的字符（统一代码点）。
`int`	`codePointCount(int beginIndex, int endIndex)` 返回此序列指定文本范围内的统一代码点。
`StringBuilder`	`delete(int start, int end)` 移除此序列的子字符串中的字符。
`StringBuilder`	`deleteCharAt(int index)` 移除此序列指定位置上的 `char`。
`void`	`ensureCapacity(int minimumCapacity)` 确保容量至少等于指定的最小值。
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` 将字符从此序列复制到目标字符数组 `dst`。
`int`	`indexOf(String str)` 返回第一次出现的指定子字符串在该字符串中的索引。
`int`	`indexOf(String str, int fromIndex)` 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
`StringBuilder`	`insert(int offset, boolean b)` 将 `boolean` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, char c)` 将 `char` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, char[] str)` 将 `char` 数组参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int index, char[] str, int offset, int len)` 将数组参数 `str` 子数组的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int dstOffset, CharSequence s)` 将指定 `CharSequence` 插入此序列中。
`StringBuilder`	`insert(int dstOffset, CharSequence s, int start, int end)` 将指定 `CharSequence` 的子序列插入此序列中。
`StringBuilder`	`insert(int offset, double d)` 将 `double` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, float f)` 将 `float` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, int i)` 将 `int` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, long l)` 将 `long` 参数的字符串表示形式插入此序列中。
`StringBuilder`	`insert(int offset, Object obj)` 将 `Object` 参数的字符串表示形式插入此字符序列中。
`StringBuilder`	`insert(int offset, String str)` 将字符串插入此字符序列中。
`int`	`lastIndexOf(String str)` 返回最右边出现的指定子字符串在此字符串中的索引。
`int`	`lastIndexOf(String str, int fromIndex)` 返回最后一次出现的指定子字符串在此字符串中的索引。
`int`	`length()` 返回长度（字符数）。
`int`	`offsetByCodePoints(int index, int codePointOffset)` 返回此序列中的一个索引，该索引是从给定 `index` 偏移 `codePointOffset` 个代码点后得到的。
`StringBuilder`	`replace(int start, int end, String str)` 使用给定 `String` 中的字符替换此序列的子字符串中的字符。
`StringBuilder`	`reverse()` 将此字符序列用其反转形式取代。
`void`	`setCharAt(int index, char ch)` 将给定索引处的字符设置为 `ch`。
`void`	`setLength(int newLength)` 设置字符序列的长度。
`CharSequence`	`subSequence(int start, int end)` 返回一个新字符序列，该字符序列是此序列的子序列。
`String`	`substring(int start)` 返回一个新的 `String`，它包含此字符序列当前所包含字符的子序列。
`String`	`substring(int start, int end)` 返回一个新的 `String`，它包含此序列当前所包含字符的子序列。
`String`	`toString()` 返回此序列中数据的字符串表示形式。
`void`	`trimToSize()` 尝试减少用于字符序列的存储空间。

append方法返回的是对象自身，即this。即使用append方法无需接收返回值，可以进行链式编程，比如string_builder.append('a').append('b').append(c')

三、包装类（java.lang包中）

1.概述

基本数据类型的数据，使用起来方便，但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本数据类型包装起来，这个类就叫包装类。
在包装类中可以定义一些方法，用来操作基本类型的数据。
因为在集合中只能存放引用类型，所以在集合中若要存放基本数据类型，可以使用包装类。

2.装箱与拆箱

装箱：从基本类型转换为对应的包装类对象。以Integer为例：Integer i = new Integer(4);这个用法现在已经过时了。或者也可以通过: Integer ii = Integer.valueOf(4);
拆箱：从包装类对象转换为对应的基本类型。以Integer为例：int num = i.intValue();
基本类型->字符串：
方法1：基本类型+”“ 例：34+“” 得到“34”，即类型的自动转换。
方法2：使用包装类中的静态方法：static String toString(int i)返回一个指定整数的String对象
方法3：使用String类中的静态方法。static String valueOf(int i) 返回int参数的字符串表示形式。
字符串->基本类型：使用包装类中的parseInt() 、 parseDouble()等

3.自动装箱与拆箱

从java5（JDK1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成，举例如下：

Integer i = 4;// 自动装箱，相当于Integer i = Integer.valueOf(4);
i = i + 5;// 等号右边，将i对象装成基本数值（自动拆箱） i.intValue() + 5;
// 加法完成后，再次装箱，把基本数值转成对象

4.iava.lang.Integer类

（1）概述

父类为：java.lang.Number
Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

（2）字段摘要

`static int`	`MAX_VALUE` 值为 231－1 的常量，它表示 `int` 类型能够表示的最大值。
`static int`	`MIN_VALUE` 值为－231 的常量，它表示 `int` 类型能够表示的最小值。
`static int`	`SIZE` 用来以二进制补码形式表示 int 值的比特位数。
`static Class<Integer>`	`TYPE` 表示基本类型 `int` 的 `Class` 实例。

（3）构造方法摘要

Integer(int value)
构造一个新分配的 Integer 对象，它表示指定的 int 值。

Integer(String s)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。传入的参数在形式上必须数字，否则会报NumberFormatException，即数字格式化异常。

（4）方法摘要

`static int`	`bitCount(int i)` 返回指定 int 值的二进制补码表示形式的 1 位的数量。
`byte`	`byteValue()` 以 `byte` 类型返回该 `Integer` 的值。
`int`	`compareTo(Integer anotherInteger)` 在数字上比较两个 `Integer` 对象。
`static Integer`	`decode(String nm)` 将 `String` 解码为 `Integer`。
`double`	`doubleValue()` 以 `double` 类型返回该 `Integer` 的值。
`boolean`	`equals(Object obj)` 比较此对象与指定对象。
`float`	`floatValue()` 以 `float` 类型返回该 `Integer` 的值。
`static Integer`	`getInteger(String nm)` 确定具有指定名称的系统属性的整数值。
`static Integer`	`getInteger(String nm, int val)` 确定具有指定名称的系统属性的整数值。
`static Integer`	`getInteger(String nm, Integer val)` 返回具有指定名称的系统属性的整数值。
`int`	`hashCode()` 返回此 `Integer` 的哈希码。
`static int`	`highestOneBit(int i)` 返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。
`int`	`intValue()` 以 `int` 类型返回该 `Integer` 的值。
`long`	`longValue()` 以 `long` 类型返回该 `Integer` 的值。
`static int`	`lowestOneBit(int i)` 返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置。
`static int`	`numberOfLeadingZeros(int i)` 在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。
`static int`	`numberOfTrailingZeros(int i)` 返回指定的 int 值的二进制补码表示形式中最低（“最右边”）的为 1 的位后面的零位个数。
`static int`	`parseInt(String s)` 将字符串参数作为有符号的十进制整数进行解析。
`static int`	`parseInt(String s, int radix)` 使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
`static int`	`reverse(int i)` 返回通过反转指定 int 值的二进制补码表示形式中位的顺序而获得的值。
`static int`	`reverseBytes(int i)` 返回通过反转指定 int 值的二进制补码表示形式中字节的顺序而获得的值。
`static int`	`rotateLeft(int i, int distance)` 返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。
`static int`	`rotateRight(int i, int distance)` 返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。
`short`	`shortValue()` 以 `short` 类型返回该 `Integer` 的值。
`static int`	`signum(int i)` 返回指定 int 值的符号函数。
`static String`	`toBinaryString(int i)` 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
`static String`	`toHexString(int i)` 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
`static String`	`toOctalString(int i)` 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
`String`	`toString()` 返回一个表示该 `Integer` 值的 `String` 对象。
`static String`	`toString(int i)` 返回一个表示指定整数的 `String` 对象。
`static String`	`toString(int i, int radix)` 返回用第二个参数指定基数表示的第一个参数的字符串表示形式。
`static Integer`	`valueOf(int i)` 返回一个表示指定的 int 值的 Integer 实例。
`static Integer`	`valueOf(String s)` 返回保存指定的 `String` 的值的 `Integer` 对象。
`static Integer`	`valueOf(String s, int radix)` 返回一个 `Integer` 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 `String` 中提取的值。

5.java.lang.Long类

（1）概述

Long 类在对象中包装了基本类型 long 的值。每个 Long 类型的对象都包含一个 long 类型的字段。
此外，该类提供了多个方法，可以将 long 转换为 String，将 String 转换为 long，除此之外，还提供了其他一些处理 long 时有用的常量和方法。

（2）字段摘要

`static long`	`MAX_VALUE` 保持 `long` 类型的最大值的常量，该值为 263-1。
`static long`	`MIN_VALUE` 保持 `long` 类型的最小值的常量，该值为 -263。
`static int`	`SIZE` 用来以二进制补码形式表示 long 值的位数。
`static Class<Long>`	`TYPE` 表示基本类型 `long` 的 `Class` 实例。

（3）构造方法摘要

Long(long value)
构造新分配的 Long 对象，表示指定的 long 参数。

Long(String s)
构造新分配的 Long 对象，表示由 String 参数指示的 long 值。

（4）方法摘要

`static int`	`bitCount(long i)` 返回指定 long 值的二进制补码表示形式中的 1 位的数量。
`byte`	`byteValue()` 以 `byte` 形式返回此 `Long` 的值。
`int`	`compareTo(Long anotherLong)` 在数字上比较两个 `Long` 对象。
`static Long`	`decode(String nm)` 将 `String` 解码成 `Long`。
`double`	`doubleValue()` 以 `double` 形式返回此 `Long` 的值。
`boolean`	`equals(Object obj)` 将此对象与指定对象进行比较。
`float`	`floatValue()` 以 `float` 形式返回此 `Long` 的值。
`static Long`	`getLong(String nm)` 确定具有指定名称的系统属性的 `long` 值。
`static Long`	`getLong(String nm, long val)` 使用指定名称确定系统属性的 `long` 值。
`static Long`	`getLong(String nm, Long val)` 使用指定名称返回系统属性的 `long` 值。
`int`	`hashCode()` 返回 `Long` 的哈希码。
`static long`	`highestOneBit(long i)` 返回至多有一个 1 位的 long 值，在指定的 long 值中最高位（最左边）的 1 位的位置。
`int`	`intValue()` 以 `int` 形式返回此 `Long` 的值。
`long`	`longValue()` 以 `long` 值的形式返回此 `Long` 的值。
`static long`	`lowestOneBit(long i)` 返回至多有一个 1 位的 long 值，在指定的 long 值中最低位（最右边）的 1 位的位置。
`static int`	`numberOfLeadingZeros(long i)` 在指定 long 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。
`static int`	`numberOfTrailingZeros(long i)` 返回在指定 long 值的二进制补码表示形式中最低位（最右边）的 1 位之后的零位的数量。
`static long`	`parseLong(String s)` 将 string 参数解析为有符号十进制 `long`。
`static long`	`parseLong(String s, int radix)` 将 string 参数解析为有符号的 `long`，基数由第二个参数指定。
`static long`	`reverse(long i)` 返回通过反转指定 long 值的二进制补码表示形式中位的顺序而获得的值。
`static long`	`reverseBytes(long i)` 返回通过反转指定 long 值的二进制补码表示形式中字节的顺序而获得的值。
`static long`	`rotateLeft(long i, int distance)` 返回根据指定的位数循环左移指定的 long 值的二进制补码表示形式而得到的值。
`static long`	`rotateRight(long i, int distance)` 返回根据指定的位数循环右移指定的 long 值的二进制补码表示形式而得到的值。
`short`	`shortValue()` 以 `short` 形式返回此 `Long` 的值。
`static int`	`signum(long i)` 返回指定 long 值的符号函数。
`static String`	`toBinaryString(long i)` 以二进制无符号整数形式返回 `long` 参数的字符串表示形式。
`static String`	`toHexString(long i)` 以十六进制无符号整数形式返回 `long` 参数的字符串表示形式。
`static String`	`toOctalString(long i)` 以八进制无符号整数形式返回 `long` 参数的字符串表示形式。
`String`	`toString()` 返回表示 `Long` 值的 `String` 对象。
`static String`	`toString(long i)` 返回表示指定 `long` 的 `String` 对象。
`static String`	`toString(long i, int radix)` 返回在使用第二个参数指定的基数时第一个参数的字符串表示形式。
`static Long`	`valueOf(long l)` 返回表示指定 long 值的 Long 实例。
`static Long`	`valueOf(String s)` 返回保持指定 `String` 的值的 `Long` 对象。
`static Long`	`valueOf(String s, int radix)` 当使用第二个参数给出的基数进行解析时，返回保持从指定 `String` 中提取的值的 `Long` 对象。

6.java.lang.Byte类

（1）概述

Byte 类将基本类型 byte 的值包装在一个对象中。一个 Byte 类型的对象只包含一个类型为 byte 的字段。
此外，该类还为 byte 和 String 的相互转换提供了几种方法，并提供了处理 byte 时非常有用的其他一些常量和方法。

（2）字段摘要

`static byte`	`MAX_VALUE` 一个常量，保存 `byte` 类型可取的最大值，即 27-1。
`static byte`	`MIN_VALUE` 一个常量，保存 `byte` 类型可取的最小值，即 -27。
`static int`	`SIZE` 用于以二进制补码形式表示 byte 值的位数。
`static Class<Byte>`	`TYPE` 表示基本类型 `byte` 的 `Class` 实例。

（3）构造方法摘要

Byte(byte value)
构造一个新分配的 Byte 对象，以表示指定的 byte 值。

Byte(String s)
构造一个新分配的 Byte 对象，以表示 String 参数所指示的 byte 值。

（4）方法摘要

`byte`	`byteValue()` 作为一个 `byte` 返回此 `Byte` 的值。
`int`	`compareTo(Byte anotherByte)` 在数字上比较两个 `Byte` 对象。
`static Byte`	`decode(String nm)` 将 `String` 解码为 `Byte`。
`double`	`doubleValue()` 作为一个 `double` 返回此 `Byte` 的值。
`boolean`	`equals(Object obj)` 将此对象与指定对象比较。
`float`	`floatValue()` 作为一个 `float` 返回此 `Byte` 的值。
`int`	`hashCode()` 返回此 `Byte` 的哈希码。
`int`	`intValue()` 作为一个 `int` 返回此 `Byte` 的值。
`long`	`longValue()` 作为一个 `long` 返回此 `Byte` 的值。
`static byte`	`parseByte(String s)` 将 string 参数解析为有符号的十进制 `byte`。
`static byte`	`parseByte(String s, int radix)` 将 string 参数解析为一个有符号的 `byte`，其基数由第二个参数指定。
`short`	`shortValue()` 作为一个 `short` 返回此 `Byte` 的值。
`String`	`toString()` 返回表示此 `Byte` 的值的 `String` 对象。
`static String`	`toString(byte b)` 返回表示指定 `byte` 的一个新 `String` 对象。
`static Byte`	`valueOf(byte b)` 返回表示指定 byte 值的一个 Byte 实例。
`static Byte`	`valueOf(String s)` 返回一个保持指定 `String` 所给出的值的 `Byte` 对象。
`static Byte`	`valueOf(String s, int radix)` 返回一个 `Byte` 对象，该对象保持从指定的 `String` 中提取的值，该值是在用第二个参数所给定的基数对指定字符串进行解析时提取的。

7.java.lang.Short类

（1）概述

Short 类在对象中包装基本类型 short 的值。一个 Short 类型的对象只包含一个 short 类型的字段。
另外，该类提供了多个方法，可以将 short 转换为 String，将 String 转换为 short，同时还提供了其他一些处理 short 时有用的常量和方法。

（2）字段摘要

`static short`	`MAX_VALUE` 保存 `short` 可取的最大值的常量，最大值为 215-1。
`static short`	`MIN_VALUE` 保存 `short` 可取的最小值的常量，最小值为 -215。
`static int`	`SIZE` 用来以二进制补码形式表示 short 值的位数。
`static Class<Short>`	`TYPE` 表示基本类型 `short` 的 `Class` 实例。

（3）构造方法摘要

Short(short value)
构造一个新分配的 Short 对象，用来表示指定的 short 值。

Short(String s)
构造一个新分配的 Short 对象，用来表示 String 参数所指示的 short 值。

（4）方法摘要

`byte`	`byteValue()` 以 `byte` 形式返回此 `Short` 的值。
`int`	`compareTo(Short anotherShort)` 比较两个 `Short` 对象所表示的数值。
`static Short`	`decode(String nm)` 将 `String` 解码为 `Short`。
`double`	`doubleValue()` 以 `double` 形式返回此 `Short` 的值。
`boolean`	`equals(Object obj)` 将此对象与指定对象比较。
`float`	`floatValue()` 以 `float` 形式返回此 `Short` 的值。
`int`	`hashCode()` 返回此 `Short` 的哈希码。
`int`	`intValue()` 以 `int` 形式返回此 `Short` 的值。
`long`	`longValue()` 以 `Long` 形式返回此 `Short` 的值。
`static short`	`parseShort(String s)` 将字符串参数解析为有符号的十进制 `short`。
`static short`	`parseShort(String s, int radix)` 将字符串参数解析为由第二个参数指定的基数中的有符号的 `short`。
`static short`	`reverseBytes(short i)` 返回通过反转指定 short 值的二进制补码表示形式中字节的顺序而获得的值。
`short`	`shortValue()` 以 `short` 形式返回此 `Short` 的值。
`String`	`toString()` 返回表示此 `Short` 的值的 `String` 对象。
`static String`	`toString(short s)` 返回表示指定 `short` 的一个新 `String` 对象。
`static Short`	`valueOf(short s)` 返回表示指定 short 值的 Short 实例。
`static Short`	`valueOf(String s)` 返回一个保持指定 `String` 所给出的值的 `Short` 对象。
`static Short`	`valueOf(String s, int radix)` 返回一个 `Short` 对象，该对象保持从指定的 `String` 中提取的值，该值是在使用第二个参数给出的基数对指定字符串进行解析时提取的。

8.java.lang.Float类

（1）概述

Float 类在对象中包装一个基本类型 float 的值。Float 类型的对象包含一个 float 类型的字段。
此外，此类提供了几种方法，可将 float 类型与 String 类型互相转换，还提供了处理 float 类型时非常有用的其他一些常量和方法。

（2）字段摘要

`static int`	`MAX_EXPONENT` 有限 `float` 变量可能具有的最大指数。
`static float`	`MAX_VALUE` 保存 `float` 类型的最大正有限值的常量，即 (2-2-23)·2127。
`static int`	`MIN_EXPONENT` 标准化 `float` 变量可能具有的最小指数。
`static float`	`MIN_NORMAL` 保存 `float` 类型数据的最小正标准值的常量，即 2-126。
`static float`	`MIN_VALUE` 保存 `float` 类型数据的最小正非零值的常量，即 2-149。
`static float`	`NaN` 保存 `float` 类型的非数字 (NaN) 值的常量。
`static float`	`NEGATIVE_INFINITY` 保存 `float` 类型的负无穷大值的常量。
`static float`	`POSITIVE_INFINITY` 保存 `float` 类型的正无穷大值的常量。
`static int`	`SIZE` 表示一个 float 值所使用的位数。
`static Class<Float>`	`TYPE` 表示 `float` 基本类型的 `Class` 实例。

（3）构造方法摘要

Float(double value)
构造一个新分配的 Float 对象，它表示转换为 float 类型的参数。

Float(float value)
构造一个新分配的 Float 对象，它表示基本的 float 参数。

Float(String s)
构造一个新分配的 Float 对象，它表示用字符串表示的 float 类型的浮点值。

（4）方法摘要

`byte`	`byteValue()` 将此 `Float` 值以 `byte` 形式返回（强制转换为 `byte`）。
`static int`	`compare(float f1, float f2)` 比较两个指定的 `float` 值。
`int`	`compareTo(Float anotherFloat)` 比较两个 `Float` 对象所表示的数值。
`double`	`doubleValue()` 返回此 `Float` 对象的 `double` 值。
`boolean`	`equals(Object obj)` 将此对象与指定对象进行比较。
`static int`	`floatToIntBits(float value)` 根据 IEEE 754 浮点“单一格式”位布局，返回指定浮点值的表示形式。
`static int`	`floatToRawIntBits(float value)` 根据 IEEE 754 浮点“单一格式”位布局，返回指定浮点值的表示形式，并保留非数字 (NaN) 值。
`float`	`floatValue()` 返回此 `Float` 对象的 `float` 值。
`int`	`hashCode()` 返回此 `Float` 对象的哈希码。
`static float`	`intBitsToFloat(int bits)` 返回对应于给定位表示形式的 `float` 值。
`int`	`intValue()` 将此 `Float` 值以 `int` 形式返回（强制转换为 `int` 类型）。
`boolean`	`isInfinite()` 如果此 `Float` 值的大小是无穷大，则返回 `true`，否则返回 `false`。
`static boolean`	`isInfinite(float v)` 如果指定数的数值是无穷大，则返回 `true`，否则返回 `false`。
`boolean`	`isNaN()` 如果此 `Float` 值是一个非数字 (NaN) 值，则返回 `true`，否则返回 `false`。
`static boolean`	`isNaN(float v)` 如果指定的数是一个非数字 (NaN) 值，则返回 `true`，否则返回 `false`。
`long`	`longValue()` 将此 `Float` 值以 `long` 形式返回（强制转换为 `long` 类型）。
`static float`	`parseFloat(String s)` 返回一个新的 `float` 值，该值被初始化为用指定 `String` 表示的值，这与 `Float` 类的 `valueOf`方法一样。
`short`	`shortValue()` 将此 `Float` 值以 `short` 形式返回（强制转换为 `short`）。
`static String`	`toHexString(float f)` 返回 `float` 参数的十六进制字符串表示形式。
`String`	`toString()` 返回此 `Float` 对象的字符串表示形式。
`static String`	`toString(float f)` 返回 `float` 参数的字符串表示形式。
`static Float`	`valueOf(float f)` 返回表示指定的 float 值的 Float 实例。
`static Float`	`valueOf(String s)` 返回保存用参数字符串 `s` 表示的 `float` 值的 `Float` 对象。

9.java.lang.Double类

（1）概述

Double 类在对象中包装一个基本类型 double 的值。每个 Double 类型的对象都包含一个 double 类型的字段。
此外，该类还提供多个方法，可以将 double 转换为 String，将 String 转换为 double，也提供了其他一些处理 double 时有用的常量和方法。

（2）字段摘要

`static int`	`MAX_EXPONENT` 有限 `double` 变量可能具有的最大指数。
`static double`	`MAX_VALUE` 保存 `double` 类型的最大正有限值的常量，最大正有限值为 (2-2-52)·21023。
`static int`	`MIN_EXPONENT` 标准化 `double` 变量可能具有的最小指数。
`static double`	`MIN_NORMAL` 保存 `double` 类型的最小正标准值的常量，最小正标准值为 2-1022。
`static double`	`MIN_VALUE` 保存 `double` 类型的最小正非零值的常量，最小正非零值为 2-1074。
`static double`	`NaN` 保存 `double` 类型的 NaN 值的常量。
`static double`	`NEGATIVE_INFINITY` 保存 `double` 类型的负无穷大值的常量。
`static double`	`POSITIVE_INFINITY` 保存 `double` 类型的正无穷大值的常量。
`static int`	`SIZE` 用于表示 double 值的位数。
`static Class<Double>`	`TYPE` 表示基本类型 `double` 的 `Class` 实例。

（3）构造方法摘要

Double(double value)
构造一个新分配的 Double 对象，它表示基本的 double 参数。

Double(String s)
构造一个新分配的 Double 对象，表示用字符串表示的 double 类型的浮点值。

（4）方法摘要

`byte`	`byteValue()` 以 `byte` 形式返回此 `Double` 的值（通过强制转换为 `byte`）。
`static int`	`compare(double d1, double d2)` 比较两个指定的 `double` 值。
`int`	`compareTo(Double anotherDouble)` 对两个 `Double` 对象所表示的数值进行比较。
`static long`	`doubleToLongBits(double value)` 根据 IEEE 754 浮点双精度格式 ("double format") 位布局，返回指定浮点值的表示形式。
`static long`	`doubleToRawLongBits(double value)` 根据 IEEE 754 浮点“双精度格式”位布局，返回指定浮点值的表示形式，并保留 NaN 值。
`double`	`doubleValue()` 返回此 `Double` 对象的 `double` 值。
`boolean`	`equals(Object obj)` 将此对象与指定对象比较。
`float`	`floatValue()` 返回此 `Double` 对象的 `float` 值。
`int`	`hashCode()` 返回此 `Double` 对象的哈希码。
`int`	`intValue()` 以 `int` 形式返回此 `Double` 的值（通过强制转换为 `int` 类型）。
`boolean`	`isInfinite()` 如果此 `Double` 值在数值上为无穷大，则返回 `true`；否则返回 `false`。
`static boolean`	`isInfinite(double v)` 如果指定数在数值上为无穷大，则返回 `true`；否则返回 `false`。
`boolean`	`isNaN()` 如果此 `Double` 值是非数字（NaN）值，则返回 `true`；否则返回 `false`。
`static boolean`	`isNaN(double v)` 如果指定的数是一个 NaN 值，则返回 `true`；否则返回 `false`。
`static double`	`longBitsToDouble(long bits)` 返回对应于给定位表示形式的 `double` 值。
`long`	`longValue()` 以 `long` 形式返回此 `Double` 的值（通过强制转换为 `long` 类型）。
`static double`	`parseDouble(String s)` 返回一个新的 `double` 值，该值被初始化为用指定 `String` 表示的值，这与 `Double` 类的 `valueOf` 方法一样。
`short`	`shortValue()` 以 `short` 形式返回此 `Double` 的值（通过强制转换为 `short`）。
`static String`	`toHexString(double d)` 返回 `double` 参数的十六进制字符串表示形式。
`String`	`toString()` 返回此 `Double` 对象的字符串表示形式。
`static String`	`toString(double d)` 返回 `double` 参数的字符串表示形式。
`static Double`	`valueOf(double d)` 返回表示指定的 double 值的 Double 实例。
`static Double`	`valueOf(String s)` 返回保存用参数字符串 `s` 表示的 `double` 值的 `Double` 对象。

10.java.lang.Short类

（1）概述

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。
此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。
字符信息基于 Unicode 标准，版本 4.0。
Character 类的方法和数据是通过 UnicodeData 文件中的信息定义的，该文件是 Unicode Consortium 维护的 Unicode Character Database 的一部分。此文件指定了各种属性，其中包括每个已定义 Unicode 代码点或字符范围的名称和常规类别。
char 数据类型（和 Character 对象封装的值）基于原始的 Unicode 规范，将字符定义为固定宽度的 16 位实体。Unicode 标准曾做过修改，以允许那些其表示形式需要超过 16 位的字符。合法代码点 的范围现在是从 U+0000 到 U+10FFFF，即通常所说的 Unicode 标量值。（请参阅 Unicode 标准中 U+n 表示法的定义。）
从 U+0000 到 U+FFFF 的字符集有时也称为 Basic Multilingual Plane (BMP)。代码点大于 U+FFFF 的字符称为增补字符。Java 2 平台在 char 数组以及 String 和 StringBuffer 类中使用 UTF-16 表示形式。在这种表现形式中，增补字符表示为一对 char 值，第一个值取自高代理项 范围，即 (\uD800-\uDBFF)，第二个值取自低代理项 范围，即 (\uDC00-\uDFFF)。
所以，char 值表示 Basic Multilingual Plane (BMP) 代码点，其中包括代理项代码点，或 UTF-16 编码的代码单元。int 值表示所有 Unicode 代码点，包括增补代码点。int 的 21 个低位（最低有效位）用于表示 Unicode 代码点，并且 11 个高位（最高有效位）必须为零。除非另有指定，否则与增补字符和代理项 char 值有关的行为如下：
只接受一个 char 值的方法无法支持增补字符。它们将代理项字符范围内的 char 值视为未定义字符。例如，Character.isLetter('\uD840') 返回 false，即使是特定值，如果在字符串的后面跟着任何低代理项值，那么它将表示一个字母。
接受一个 int 值的方法支持所有 Unicode 字符，其中包括增补字符。例如，Character.isLetter(0x2F81A) 返回 true，因为代码点值表示一个字母（一个 CJK 象形文字）。

（2）字段摘要

`static byte`	`COMBINING_SPACING_MARK` Unicode 规范中的常规类别“Mc”。
`static byte`	`CONNECTOR_PUNCTUATION` Unicode 规范中的常规类别“Pc”。
`static byte`	`CONTROL` Unicode 规范中的常规类别“Cc”。
`static byte`	`CURRENCY_SYMBOL` Unicode 规范中的常规类别“Sc”。
`static byte`	`DASH_PUNCTUATION` Unicode 规范中的常规类别“Pd”。
`static byte`	`DECIMAL_DIGIT_NUMBER` Unicode 规范中的常规类别“Nd”。
`static byte`	`DIRECTIONALITY_ARABIC_NUMBER` Unicode 规范中的弱双向字符类型“AN”。
`static byte`	`DIRECTIONALITY_BOUNDARY_NEUTRAL` Unicode 规范中的弱双向字符类型“BN”。
`static byte`	`DIRECTIONALITY_COMMON_NUMBER_SEPARATOR` Unicode 规范中的弱双向字符类型“CS”。
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER` Unicode 规范中的弱双向字符类型“EN”。
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR` Unicode 规范中的弱双向字符类型“ES”。
`static byte`	`DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR` Unicode 规范中的弱双向字符类型“ET”。
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT` Unicode 规范中的强双向字符类型“L”。
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING` Unicode 规范中的强双向字符类型“LRE”。
`static byte`	`DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE` Unicode 规范中的强双向字符类型“LRO”。
`static byte`	`DIRECTIONALITY_NONSPACING_MARK` Unicode 规范中的弱双向字符类型“NSM”。
`static byte`	`DIRECTIONALITY_OTHER_NEUTRALS` Unicode 规范中的非特定双向字符类型“ON”。
`static byte`	`DIRECTIONALITY_PARAGRAPH_SEPARATOR` Unicode 规范中的非特定双向字符类型“B”。
`static byte`	`DIRECTIONALITY_POP_DIRECTIONAL_FORMAT` Unicode 规范中的弱双向字符类型“PDF”。
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT` Unicode 规范中的强双向字符类型“R”。
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC` Unicode 规范中的强双向字符类型“AL”。
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING` Unicode 规范中的强双向字符类型“RLE”。
`static byte`	`DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE` Unicode 规范中的强双向字符类型“RLO”。
`static byte`	`DIRECTIONALITY_SEGMENT_SEPARATOR` Unicode 规范中的非特定双向字符类型“S”。
`static byte`	`DIRECTIONALITY_UNDEFINED` 未定义的双向字符类型。
`static byte`	`DIRECTIONALITY_WHITESPACE` Unicode 规范中的非特定双向字符类型“WS”。
`static byte`	`ENCLOSING_MARK` Unicode 规范中的常规类别“Me”。
`static byte`	`END_PUNCTUATION` Unicode 规范中的常规类别“Pe”。
`static byte`	`FINAL_QUOTE_PUNCTUATION` Unicode 规范中的常规类别“Pf”。
`static byte`	`FORMAT` Unicode 规范中的常规类别“Cf”。
`static byte`	`INITIAL_QUOTE_PUNCTUATION` Unicode 规范中的常规类别“Pi”。
`static byte`	`LETTER_NUMBER` Unicode 规范中的常规类别“Nl”。
`static byte`	`LINE_SEPARATOR` Unicode 规范中的常规类别“Zl”。
`static byte`	`LOWERCASE_LETTER` Unicode 规范中的常规类别“Ll”。
`static byte`	`MATH_SYMBOL` Unicode 规范中的常规类别“Sm”。
`static int`	`MAX_CODE_POINT` Unicode 代码点的最大值。
`static char`	`MAX_HIGH_SURROGATE` UTF-16 编码中的 Unicode 高代理项代码单元的最大值。
`static char`	`MAX_LOW_SURROGATE` UTF-16 编码中的 Unicode 低代理项代码单元的最大值。
`static int`	`MAX_RADIX` 可用于与字符串相互转换的最大基数。
`static char`	`MAX_SURROGATE` UTF-16 编码中的 Unicode 代理项代码单元的最大值。
`static char`	`MAX_VALUE` 此字段的常量值是 `char` 类型的最大值，即 `'\uFFFF'`。
`static int`	`MIN_CODE_POINT` Unicode 代码点的最小值。
`static char`	`MIN_HIGH_SURROGATE` UTF-16 编码中的 Unicode 高代理项代码单元的最小值。
`static char`	`MIN_LOW_SURROGATE` UTF-16 编码中的 Unicode 低代理项代码单元的最小值。
`static int`	`MIN_RADIX` 可用于与字符串相互转换的最小基数。
`static int`	`MIN_SUPPLEMENTARY_CODE_POINT` 增补代码点的最小值。
`static char`	`MIN_SURROGATE` UTF-16 编码中的 Unicode 代理项代码单元的最小值。
`static char`	`MIN_VALUE` 此字段的常量值是 `char` 类型的最小值，即 `'\u0000'`。
`static byte`	`MODIFIER_LETTER` Unicode 规范中的常规类别“Lm”。
`static byte`	`MODIFIER_SYMBOL` Unicode 规范中的常规类别“Sk”。
`static byte`	`NON_SPACING_MARK` Unicode 规范中的常规类别“Mn”。
`static byte`	`OTHER_LETTER` Unicode 规范中的常规类别“Lo”。
`static byte`	`OTHER_NUMBER` Unicode 规范中的常规类别“No”。
`static byte`	`OTHER_PUNCTUATION` Unicode 规范中的常规类别“Po”。
`static byte`	`OTHER_SYMBOL` Unicode 规范中的常规类别“So”。
`static byte`	`PARAGRAPH_SEPARATOR` Unicode 规范中的常规类别“Zp”。
`static byte`	`PRIVATE_USE` Unicode 规范中的常规类别“Co”。
`static int`	`SIZE` 用来以无符号二进制形式表示 char 值的位数。
`static byte`	`SPACE_SEPARATOR` Unicode 规范中的常规类别“Zs”。
`static byte`	`START_PUNCTUATION` Unicode 规范中的常规类别“Ps”。
`static byte`	`SURROGATE` Unicode 规范中的常规类别“Cs”。
`static byte`	`TITLECASE_LETTER` Unicode 规范中的常规类别“Lt”。
`static Class<Character>`	`TYPE` 表示基本类型 `char` 的 `Class` 实例。
`static byte`	`UNASSIGNED` Unicode 规范中的常规类别“Cn”。
`static byte`	`UPPERCASE_LETTER` Unicode 规范中的常规类别“Lu”。

（3）构造方法摘要

Character(char value)
构造一个新分配的 Character 对象，用以表示指定的 char 值。

（4）方法摘要

`static int`	`charCount(int codePoint)` 确定表示指定字符（Unicode 代码点）所需的 `char` 值的数量。
`char`	`charValue()` 返回此 `Character` 对象的值。
`static int`	`codePointAt(char[] a, int index)` 返回 `char` 数组的给定索引上的代码点。
`static int`	`codePointAt(char[] a, int index, int limit)` 返回 `char` 数组的给定索引上的代码点，该数组中只有那些具有小于 `limit` 的 `index` 值的数组元素可以使用。
`static int`	`codePointAt(CharSequence seq, int index)` 返回 `CharSequence` 的给定索引上的代码点。
`static int`	`codePointBefore(char[] a, int index)` 返回 `char` 数组的给定索引前面的代码点。
`static int`	`codePointBefore(char[] a, int index, int start)` 返回 `char` 数组的给定索引前面的代码点，该数组中只有那些具有大于等于 `start` 的 `index`值的数组元素可以使用。
`static int`	`codePointBefore(CharSequence seq, int index)` 返回 `CharSequence` 的给定索引前面的代码点。
`static int`	`codePointCount(char[] a, int offset, int count)` 返回 `char` 数组参数的子数组中 Unicode 代码点的数量。
`static int`	`codePointCount(CharSequence seq, int beginIndex, int endIndex)` 返回指定字符序列的文本范围内的 Unicode 代码点数量。
`int`	`compareTo(Character anotherCharacter)` 根据数字比较两个 `Character` 对象。
`static int`	`digit(char ch, int radix)` 返回使用指定基数的字符 `ch` 的数值。
`static int`	`digit(int codePoint, int radix)` 返回使用指定基数的指定字符（Unicode 代码点）的数值。
`boolean`	`equals(Object obj)` 将此对象与指定对象比较。
`static char`	`forDigit(int digit, int radix)` 确定使用指定基数的特定数字的字符表示形式。
`static byte`	`getDirectionality(char ch)` 返回给定字符的 Unicode 方向属性。
`static byte`	`getDirectionality(int codePoint)` 返回给定字符（Unicode 代码点）的 Unicode 方向属性。
`static int`	`getNumericValue(char ch)` 返回指定的 Unicode 字符表示的 `int` 值。
`static int`	`getNumericValue(int codePoint)` 返回指定字符（Unicode 代码点）表示的 `int` 值。
`static int`	`getType(char ch)` 返回一个指示字符的常规类别的值。
`static int`	`getType(int codePoint)` 返回一个指示字符的常规类别的值。
`int`	`hashCode()` 返回此 `Character` 的哈希码。
`static boolean`	`isDefined(char ch)` 确定字符是否被定义为 Unicode 中的字符。
`static boolean`	`isDefined(int codePoint)` 确定字符（Unicode 代码点）是否被定义为 Unicode 中的字符。
`static boolean`	`isDigit(char ch)` 确定指定字符是否为数字。
`static boolean`	`isDigit(int codePoint)` 确定指定字符（Unicode 代码点）是否为数字。
`static boolean`	`isHighSurrogate(char ch)` 确定给出的 `char` 值是否为一个高代理项代码单元（也称为前导代理项代码单元）。
`static boolean`	`isIdentifierIgnorable(char ch)` 确定是否应该认为指定字符是 Java 标识符或 Unicode 标识符中可忽略的一个字符。
`static boolean`	`isIdentifierIgnorable(int codePoint)` 确定是否应该认为指定字符（Unicode 代码点）是 Java 标识符或 Unicode 标识符中可忽略的一个字符。
`static boolean`	`isISOControl(char ch)` 确定指定字符是否为 ISO 控制字符。
`static boolean`	`isISOControl(int codePoint)` 确定引用的字符（Unicode 代码点）是否为 ISO 控制字符。
`static boolean`	`isJavaIdentifierPart(char ch)` 确定指定字符是否可以是 Java 标识符中首字符以外的部分。
`static boolean`	`isJavaIdentifierPart(int codePoint)` 确定字符（Unicode 代码点）是否可以是 Java 标识符中首字符以外的部分。
`static boolean`	`isJavaIdentifierStart(char ch)` 确定是否允许将指定字符作为 Java 标识符中的首字符。
`static boolean`	`isJavaIdentifierStart(int codePoint)` 确定是否允许将字符（Unicode 代码点）作为 Java 标识符中的首字符。
`static boolean`	`isJavaLetter(char ch)` 已过时。由 isJavaIdentifierStart(char) 取代。
`static boolean`	`isJavaLetterOrDigit(char ch)` 已过时。由 isJavaIdentifierPart(char) 取代。
`static boolean`	`isLetter(char ch)` 确定指定字符是否为字母。
`static boolean`	`isLetter(int codePoint)` 确定指定字符（Unicode 代码点）是否为字母。
`static boolean`	`isLetterOrDigit(char ch)` 确定指定字符是否为字母或数字。
`static boolean`	`isLetterOrDigit(int codePoint)` 确定指定字符（Unicode 代码点）是否为字母或数字。
`static boolean`	`isLowerCase(char ch)` 确定指定字符是否为小写字母。
`static boolean`	`isLowerCase(int codePoint)` 确定指定字符（Unicode 代码点）是否为小写字母。
`static boolean`	`isLowSurrogate(char ch)` 确定给定 `char` 值是否一个低代理项代码单元（也称为尾部代理项代码单元）。
`static boolean`	`isMirrored(char ch)` 确定指定字符依据 Unicode 规范是否对称。
`static boolean`	`isMirrored(int codePoint)` 确定指定字符（Unicode 代码点）依据 Unicode 规范是否对称。
`static boolean`	`isSpace(char ch)` 已过时。由 isWhitespace(char) 取代。
`static boolean`	`isSpaceChar(char ch)` 确定指定字符是否为 Unicode 空白字符。
`static boolean`	`isSpaceChar(int codePoint)` 确定指定字符（Unicode 代码点）是否为 Unicode 空白字符。
`static boolean`	`isSupplementaryCodePoint(int codePoint)` 确定指定字符（Unicode 代码点）是否在增补字符范围内。
`static boolean`	`isSurrogatePair(char high, char low)` 确定指定的 `char` 值对是否为有效的代理项对。
`static boolean`	`isTitleCase(char ch)` 确定指定字符是否为首字母大写字符。
`static boolean`	`isTitleCase(int codePoint)` 确定指定字符（Unicode 代码点）是否为首字母大写字符。
`static boolean`	`isUnicodeIdentifierPart(char ch)` 确定指定字符是否可以是 Unicode 标识符中首字符以外的部分。
`static boolean`	`isUnicodeIdentifierPart(int codePoint)` 确定指定字符（Unicode 代码点）是否可以是 Unicode 标识符中首字符以外的部分。
`static boolean`	`isUnicodeIdentifierStart(char ch)` 确定是否允许将指定字符作为 Unicode 标识符中的首字符。
`static boolean`	`isUnicodeIdentifierStart(int codePoint)` 确定是否允许将指定字符（Unicode 代码点）作为 Unicode 标识符中的首字符。
`static boolean`	`isUpperCase(char ch)` 确定指定字符是否为大写字母。
`static boolean`	`isUpperCase(int codePoint)` 确定指定字符（Unicode 代码点）是否为大写字母。
`static boolean`	`isValidCodePoint(int codePoint)` 确定指定的代码点是否为从 `0x0000` 到 `0x10FFFF` 范围之内的有效 Unicode 代码点值。
`static boolean`	`isWhitespace(char ch)` 确定指定字符依据 Java 标准是否为空白字符。
`static boolean`	`isWhitespace(int codePoint)` 确定指定字符（Unicode 代码点）依据 Java 标准是否为空白字符。
`static int`	`offsetByCodePoints(char[] a, int start, int count, int index, int codePointOffset)` 返回给定 `char` 子数组中的索引，它是从给定 `index` 到 `codePointOffset` 代码点的偏移量。
`static int`	`offsetByCodePoints(CharSequence seq, int index, int codePointOffset)` 返回给定字符序列中的索引，它是从给定 `index` 到 `codePointOffset` 代码点的偏移量。
`static char`	`reverseBytes(char ch)` 返回通过反转指定 char 值中的字节顺序而获得的值。
`static char[]`	`toChars(int codePoint)` 将指定的字符（Unicode 代码点）转换成其存储在 `char` 数组中的 UTF-16 表示形式。
`static int`	`toChars(int codePoint, char[] dst, int dstIndex)` 将指定字符（Unicode 代码点）转换为其 UTF-16 表示形式。
`static int`	`toCodePoint(char high, char low)` 将指定的代理项对转换为其增补代码点值。
`static char`	`toLowerCase(char ch)` 使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。
`static int`	`toLowerCase(int codePoint)` 使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为小写。
`String`	`toString()` 返回表示此 `Character` 值的 `String` 对象。
`static String`	`toString(char c)` 返回一个表示指定 `char` 值的 `String` 对象。
`static char`	`toTitleCase(char ch)` 使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为首字母大写。
`static int`	`toTitleCase(int codePoint)` 使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为首字母大写。
`static char`	`toUpperCase(char ch)` 使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
`static int`	`toUpperCase(int codePoint)` 使用取自 UnicodeData 文件的大小写映射信息将字符（Unicode 代码点）参数转换为大写。
`static Character`	`valueOf(char c)` 返回一个表示指定 char 值的 Character 实例。

（5）嵌套类摘要

`static class`	`Character.Subset` 此类的实例表示 Unicode 字符集的特定子集。
`static class`	`Character.UnicodeBlock` 表示 Unicode 规范中字符块的一系列字符子集。

11.java.lang.Boolean类

（1）概述

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。
此外，此类还为 boolean 和 String 的相互转换提供了许多方法，并提供了处理 boolean 时非常有用的其他一些常量和方法。

（2）字段摘要

`static Boolean`	`FALSE` 对应基值 `false` 的 `Boolean` 对象。
`static Boolean`	`TRUE` 对应基值 `true` 的 `Boolean` 对象。
`static Class<Boolean>`	`TYPE` 表示基本类型 boolean 的 Class 对象。

（3）构造方法摘要

Boolean(boolean value)
分配一个表示 value 参数的 Boolean 对象。

Boolean(String s)
如果 String 参数不为 null 且在忽略大小写时等于 "true"，则分配一个表示 true 值的 Boolean 对象。

（4）方法摘要

`boolean`	`booleanValue()` 将此 Boolean 对象的值作为基本布尔值返回。
`int`	`compareTo(Boolean b)` 将此 Boolean 实例与其他实例进行比较。
`boolean`	`equals(Object obj)` 当且仅当参数不是 `null`，而是一个与此对象一样，都表示同一个 `Boolean` 值的 `boolean` 对象时，才返回 `true`。
`static boolean`	`getBoolean(String name)` 当且仅当以参数命名的系统属性存在，且等于 `"true"` 字符串时，才返回 `true`。
`int`	`hashCode()` 返回该 Boolean 对象的哈希码。
`static boolean`	`parseBoolean(String s)` 将字符串参数解析为 boolean 值。
`String`	`toString()` 返回表示该布尔值的 String 对象。
`static String`	`toString(boolean b)` 返回一个表示指定布尔值的 String 对象。
`static Boolean`	`valueOf(boolean b)` 返回一个表示指定 boolean 值的 Boolean 实例。
`static Boolean`	`valueOf(String s)` 返回一个用指定的字符串表示值的 `Boolean` 值。

志行千里者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之进阶语法（System类、StringBuilder及包装类）

一、System类java.lang.System类包含一些有用的类字段和方法，可以获取与系统相关的信息或是系统级操作。它不能被实例化。在System类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。// System类常用的方法有两个，分别为：// public static long currentTimeMillis():返回以毫秒为单位的当前时间，用来测试程序的效率// public s...
复制链接

扫一扫