黑马程序员_Java基础_前期准备01_3.1

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------

前期准备01-3.1

 

Java的API：

API(Application Programming Interface，应用程序编程接口)是一些被预先定义的函数，目的是提供给应用程序与开发人员，基于某软件或硬件的可以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。

 

一、String/*[striŋ]*/类

public final class String

extends Object

implements Serializable，CharSequence，Comparable<String>

/*['siriəlaizəbl]序列化[tʃa:'si:kwns]字符序列['kʌmprəbl]可比较的*/

①String类概述

❶String类代表字符串。Java程序中所有的字符串，都是此类的一个实例对象。String类适用于描述字符串事物，提供了多个对字符串进行操作的方法。

❷字符串是常量。所有字符串的值，在初始化之后就不能够再被改变。

❸字符串常量池(方法区)。因为String对象是不可变的，所以可以共享。

❹字符串缓冲区支持可变的字符串。

❺Java语言提供了对字符串串联的符号(+)。字符串的串联，是通过StringBuilder/*[striŋ]['bildə]*/类(或者StringBuffer/*[striŋ]['bʌfə]*/类)及其append/*[ə'pend]附加*/方法实现的。

❻Java语言提供了将其它对象转换为字符串的特殊支持。字符串的转换是通过toString方法来实现的，该方法由Object类定义，并可以被Java中的所有类继承。

❼初始化String s = “abc”；然后s = “bcd”；对于字符串“abc”，此对象还在内存中，并没用被改变，只是s的值变化了，其引用变为了字符串“bcd”的地址。

❽对于String s1 = “abc”和String s2 = new String(“abc”)的区别：

s1：在内存中有一个对象。其被创建时，首先查看“String常量池”中是否存在字符串“abc”，如果存在则直接将“abc”赋值给s1；如果不存在，则先在“String常量池”中新建一个字符串“abc”，然后再将其赋值给s1。

s2：在内存中有两个对象。其被创建时，不管“String常量池”中是否存在字符串“abc”，先直接在堆内存中新建一个字符串“abc”，然后将其赋值给s2，并且在“String常量池”中创建“abc”。这种方式创建的两个对象，一个在堆内存中，一个在“String常量池”中。

以上两种初始化的区别就是，第一种只在“String常量池”中创建一个对象；第二种除了在“String常量池”中创建一个对象之外，还要在堆内存中创建一个对象。

❾String类中的equals方法被重写，表示判断两个字符串的内容是否相同。

❿对于字符串而言，只要其内容是相同的，所有的引用都指向同一个对象。

②Sting类的方法：获取

❶字符串中包含的字符数，也就是字符串的长度

注意：数组中的length是属性，没有括号；String类中的length()是方法，有括号。

public int length()/*[leŋθ]长度*/

返回此字符串的长度。长度等于字符串中的Unicode代码单元的数量。

❷根据位置获取位置上的字符

public char charAt(int index)/*['indeks]索引*/

返回指定索引处的char值。索引的范围从0到length()-1。如果角标越界，则会抛出StringIndexOutOfBoundsException。

❸根据字符获取该字符在字符串中的位置

public int indexOf(int ch)

返回指定字符在此字符串中，第一次出现处的索引。若未找到该字符，则返回-1。ch表示一个字符。

public int indexOf(int ch，int fromIndex)

返回指定字符在此字符串中，第一次出现处的索引，并且从指定的索引处开始搜索。若未找到该字符，则返回-1。如果角标越界，则会抛StringIndexOutOfBoundsException。

public int lastIndexOf(int ch)

返回指定字符在此字符串中，最后一次出现的索引。若未找到该字符，则返回-1。

public int lastIndexOf(int ch，int fromIndex)

返回指定字符在此字符串中，最后一次出现处的索引，并且从指定的索引处进行反向搜索。若未找到该字符，则返回-1。如果角标越界，则会抛出StringIndexOutOfBoundsException。

❹根据字符串获取该子串在字符串中的位置

public int indexOf(String str)

返回指定子串在此字符串中，第一次出现处的索引。此索引为该子串第一个字符处的索引。若未找到该子串，则返回-1。str表示一个字符串。

当返回值为-1时，表示该字符串中没有指定的子串，也可以用于判断，该字符串中是否包含指定的子串。

如果，既需要判断一个字符串中是否包含一个子串，又要获取子串出现的位置，就用indexOf方法。如果只是判断是否包含某个子串，可以用contains/*[kən'teinz]包含*/方法。

public int indexOf(String str，int fromIndex)

返回指定子串在此字符串中，第一次出现处的索引，并且从指定的索引处开始搜索。此索引为该子串第一个字符处的索引。若未找到该子串，则返回-1。如果角标越界，则会抛出StringIndexOutOfBoundsException。

public int lastIndexOf(String str)

返回指定子串在此字符串中，最后一次出现的索引。此索引为该子串第一个字符处的索引。若未找到该子串，则返回-1。

public int lastIndexOf(String str，int fromIndex)

返回指定子串在此字符串中，最后一次出现处的索引，并且从指定的索引处进行反向搜索。此索引为该子串第一个字符处的索引。若未找到该子串，则返回-1。如果角标越界，则会抛出StringIndexOutOfBoundsException。

③Sting类的方法：判断

❶字符串中是否包含某一个子串

public boolean contains(CharSequence s)/*[kən'teinz]包含['si:kwns]序列*/

当且仅当此字符串包含指定的char值序列时，返回true，否则返回false。

❷字符串中是否有内容(从1.6开始)

public boolean isEmpty()/*['empti]空的*/

当且仅当此字符串的length()为0时，返回true，否则返回false。

null和“”：前者表示指向空；后者是个对象，对象是空。

❸字符串是否以指定内容开头

public boolean startsWith(String prefix)/*['pri:fiks]前缀*/

判断此字符串是否以指定的前缀开始。如果是，就返回true；否则返回false。注意，如果参数是空字符串，或者是此String对象，则返回true。

❹字符串是否以指定内容结尾

public boolean endsWith(String suffix)/*['sʌfiks]后缀*/

判断此字符串是否以指定的后缀开始。如果是，就返回true；否则返回false。注意，如果参数是空字符串，或者是此String对象，则返回true。

❺判断字符串的内容是否相同，覆盖了Object类的方法

public boolean equals(Object anObject)

将此字符串与指定的对象比较。当且仅当该参数不为null，并且与此对象表示相同字符序列的String对象时，结果为true，否则结果为false。此方法不忽略大小写。

❻判断字符串的内容是否相同，并忽略大小写。

public boolean equalsIgnoreCase(String anotherString)

/*[ig'nɔ:]忽视[keis]情况*/

将此String对象与参数String对象向比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等(忽略大小写)，则认为这两个字符串是相等的，返回结果为true，否则返回false。

④String类的方法：转换

❶将字符数组转换成字符串

一是通过构造函数：

public String(char[] value)/*['vælju:]值*/

将字符数组中的全部元素，转换成字符串。

public String(char[] value，int offset，int count)/*['ɔfset]偏移量['kaunt]计数*/

将字符数组中的偏移了指定位数后的某几个元素，转换成字符串。

value：传入的字符数组

offset：初始偏移量(子数组中元素的第一个索引)

count：元素个数(子数组的长度)

传入的offset和count有一个发生错误，抛出角标越界异常。

二是通过调用静态方法：

public static String copyValueOf(char[] data)/*['deitə]数据*/

返回指定字符数组中表示该字符序列的String对象。

Public static String copyValueOf(char[] data，int offset，int count)

返回该字符数组中，表示其所指定子数组的字符序列的String对象。

data：字符数组

offset：子数组的初始偏移量

count：子数组的长度

传入的offset和count有一个发生错误，抛出角标越界异常。

❷将字符串转换成字符数组

public char[] toCharArray()

将此字符串转换为一个新的字符数组。该字符数组的长度，就是此字符串的长度，其内容包含此字符串所表示的字符序列。

❸将字节数组转换成字符串

public String(byte[] bytes)

通过使用平台的默认字符集解码传入的byte数组，构造成一个新的String对象。新的String对象的长度是字符集的函数，因此可能不等于byte数组的长度。当传入的byte在给定的字符集中无效时，此构造方法的行为没有指定。

public String(byte[] bytes，int offset，int length)

通过使用平台的默认字符集解码传入的byte数组，将其指定的子数组，构造成一个新的String对象。新的String对象的长度是字符集的函数，因此可能不等于byte数组的长度。当传入的byte在给定的字符集中无效时，此构造方法的行为没有指定。

bytes：要解码为字符的byte数组

offset：要解码的byte数组中第一个元素的索引

length：要解码的元素个数

传入的offset和length中有一个发生错误，抛出角标越界异常。

❹将字符串转换成字节数组

public byte[] getBytes()

使用平台的默认字符集，将此String对象编码为byte序列，并将结果存储到一个新的byte数组中。当此字符串不能使用默认的字符集编码时，此方法的行为没有指定。

❺字符串和字节数组在转换过程中，可以指定编码表。

❻将基本数据类型转换成字符串

public static String valueOf(参数列表)

返回该参数的字符串表示形式。

(boolean b)：参数为true，返回字符串true；参数为false，返回字符串false。

(char c)：返回一个长度为1的字符串，包含参数c的单个字符。

(int i)：返回int参数的String对象。将该参数转换为有符号的十进制表示形式，并以字符串的形式返回它。

(long l)：返回long参数的字符串表示形式。将该参数转换为有符号的十进制表示形式，并以字符串的形式返回它。

(float f)：返回float参数的字符串表示形式。结果是表示参数的符号和数值(绝对值)的字符串。符号为负，那么结果的第一个字符是‘-’；结果为正，则结果中不显示符号字符。小数点用‘.’表示，需要科学计数的用‘E’，无穷大用“Infinity”/*[in'finiti]无穷*/表示。

(double d)：返回double参数的字符串表示形式。规则同float。

(Object obj)：返回Object参数的字符串表示形式。如果参数为null，则字符串等于“null”；否则，返回obj.toString()的值。

(char[] data)：返回char数组的字符串表示形式。字符数组的内容已被复制，后续修改不会影响新创建的字符串。同copyValueOf。

(char[] dara，int offset，int count)：返回字符数组的特定子数组的字符串表示形式。同copyValueOf。

data：字符数组

offset：String子数组的初始偏移量

count：String子数组的长度

对于valueOf的使用，最简单的形式：3+“”效果等同于String.valueOf(3)。

⑤String类的方法：替换

❶单个字符替换

public String replace(char oldChar，char newChar)/*[ri'pleis]替换*/

返回一个新的字符串，它是通过用newChar替换掉此字符串中出现的所有oldChar得到的。

如果oldChar在此String对象表示的字符序列中没有出现过，则返回此String对象的引用。否则，就创建一个新的String对象，它表示的字符序列，除了所有的oldChar都被替换为newChar之外，与此String对象所表示的字符序列都是相同的。

❷字符串替换

public String replace(CharSequence target，CharSquence replacement)

/*[ri'pleis]替换['si:kwns]序列['ta:git]目标[ri'pleismənt]代替者*/

使用指定的字符序列替换此字符串中所有相匹配的子串。该替换从字符串的开头位置向末尾位置执行。例如：用‘b’替换字符串中的“aaa”中的“aa”，将生成“ba”，而不是“ab”。

target：要被替换的char值序列(将被换出的子串)

replacement：char值的替换序列(将被换入的新序列)

⑥String的方法：切割

public String[] split(String regex)/*[split]分离['regeks]正则表达式*/

(正则表达式：regular expression,['regjulə]有规律的[ik'spreʃən]符号)

根据给定正则表达式的匹配，拆分此字符串，返回一个字符串数组。

regex：正则表达式，需要用双引号引起来

若正则表达式语法无效，抛出PatternSyntaxException异常。

/*['pætn]模式['sintæks]语法*/(正则表达式模式的语法异常)

⑦String类的方法：获取字符串中的一部分

❶public String substring(intbeginIndex)/*['sʌbˌstriŋ]子串*/

返回一个新的字符串。该字符串从指定索引处的字符开始，直到此字符串的结尾。如果给定的数值为负数或者大于字符串的长度，会发生角标越界异常。

可概括为：从指定位置开始到结尾。

❷public String substring(intbeginIndex，int endIndex)

返回一个新的字符串。该字符串从指定的beginIndex处开始，直到索引endIndex-1处的字符为止。新字符串的长度为：endIndex-beginIndex。所传入两个索引中只要有一个是错误的，即抛出角标越界异常。

可概括为：包含头，不包含尾。

⑧String类的方法：转换大小写、去除两端空格、比较字典顺序

❶将字符串转换成大写或者小写

public String toUpperCase()/*['ʌpəˌkeis]大写字母*/

使用默认语言环境的规则，将此String对象中的所有字符，都转换为大写。

public String toLowerCase()/*['ləuəˌkeis]小写字母*/

使用默认语言环境的规则，将此String对象中的所有字符，都转换为小写。

❷将字符串两端的多个空格去除

public String trim()/*[trim]修剪*/

返回字符串的副本，忽略前导空格和尾部空格。如果，此字符串没有前导空格和尾部空格，则返回其自身。

❸对两个字符串进行自然顺序的比较

public int compareTo(String anotherString)/*[kəm'peə]比较*/

按字典顺序比较两个字符串。该比较基于字符串中各个字符的Unicode值。

如果此字符串等于参数字符串，返回0；如果此字符串按字典顺序小于参数字符串，返回负数；如果此字符串按字典顺序大于参数字符串，返回正数。

当且仅当，该字符串在方法equals(Object)返回true时，返回值才为0。

 

二、StringBuffer/*['bʌfə]缓冲区*/类

public final class StringBuffer

extends Object

implements Serializable，CharSequence

/*['siriəlaizəbl]序列化[tʃa:'si:kwns]字符序列*/

①StringBuffer概述

❶StringBuffer是一个容器，是字符串缓冲区。

❷StringBuffer可以对字符串的内容进行存储、删除、获取、修改。

CURD：create、update、read、delete。

/*[kri:'eit]创建[ʌp'deit]校正[ri:d]读取[di'li:t]删除*/

❸字符串的组成原理，就是通过该类实现的。有很多方法与String相同。

❹StringBuffer的长度是可变的。并且是线程安全的可变字符串序列。

②StringBuffer类的方法：存储

❶public StringBuffer append(参数列表)/*[ə'pend]添加*/

其返回值都是StringBuffer的一个引用。都是添加到内容的结尾处。

(boolean b)：将boolean参数的字符串表示形式追加到序列中。

(char c)：将char参数的字符串表示形式追加到序列中，此序列的长度加1。

(double d)：将double参数的字符串表示形式追加到序列中。

(float f)：将float参数的字符串表示形式追加到序列中。

(int i)：将int参数的字符串表示形式追加到序列中。

(long lng)：将long参数的字符串表示形式追加到序列中。

(Object obj)：先将参数转换成字符串，然后将所得的字符串追加到此序列中。

(String str)：按原有顺序追加String参数中的字符，使此序列的长度增加该参数的长度。如果str为null，则追加字符串“null”。

(StringBuffer sb)：按顺序将StringBuffer参数中的字符追加到此StringBuffer中，并使此StringBuffer的长度增加StringBuffer参数的长度。如果sb为null，则追加字符串“null”。

(char[] str)：按原有顺序将数组参数中的字符追加到此序列中。此序列的长度将增加该数组参数的长度。

(char[] str，int offset，int len)：将char[]数组str中的指定元素，按顺序追加到此序列中，从str的索引offset处开始。此序列的长度将增加len。

str：要追加的字符数组

offset：要追加的第一个元素在str中的索引

len ：要追加的元素的个数

如果offset和len中有一个发生错误，抛出数组角标越界异常。

❷方法调用链：方法返回的依然是本类对象，还可以继续调用本类的方法。

StringBuffer sb = new StringBuffer()；

sb.append(“abc”).append(123).append(true)；

❸StringBuffer是一个容器，无论其中的内容怎么变化，容器是固定的。当方法的返回依然是本类对象时，不管有多少个引用指向它，也只有一个容器存在。

❹public StringBuffer insert(intoffset，参数类型)/*[in'sə:t]插入*/

offset：偏移量

返回值都是一个引用。如果偏移量异常，则抛出字符串角标越界异常。

(boolean b)：将boolean参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中。

(char c)：将char参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中，此序列的长度加1。

(double d)：将double参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中。

(float f)：将float参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中。

(int i)：将int参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中。

(long l)：将long参数的字符串表示形式，在原有数据的开始处偏移offset位后，插入此序列中。

(Object obj)：先将参数转换成字符串，然后将所得的字符串，在原有数据的开始处偏移offset位后，插入此序列中。

(String str)：按原有顺序将String参数中的字符插入此序列中的指定位置，将该位置处原来的字符向后移，此序列将增加该参数的长度。如果，str为null，则向此序列中追加字符串“null”。

(char[] str)：数组参数的字符将被插入此序列中offset所指示的位置处，此序列的长度将增加该数组的长度。

public StringBuffer insert(int index，char[] str，int offset，int len)

将str数组参数的指定子数组的字符串表示形式，从该序列的开始出偏移offset位之后，插入此序列中。该序列的长度增加所插入的子数组的长度。

index：此序列将中要插入子数组的位置

str：一个char数组

offset：char数组中子数组元素的第一个位置

len：子数组的长度

所传入的三个数值中有一个发生错误，即抛出字符串角标越界异常。

❺StringBuffer的长度是变化的，而数组的长度是固定的。StringBuffer可以同时操作多种数据类型，而数组被定义之后只能操作一种数据类型。

❻缓冲区的三个特点：长度是可变的，可以直接操作多种数据类型，最终可以通过toString方法变成字符串的形式。

③StringBuffer类的方法：删除

❶pubic StringBuffer delete(intstart，int end)

移除该序列中的字符子串。该子串从指定的start处开始，一直到索引end-1处。如果start等于end，则不发生任何更改。

start：起始索引(包含)

end：结束索引(不包含)

如果传入的索引数据异常，则发生字符串角标越界异常。

若要清空StringBuffer缓冲区，可以让start=0，end=该引用.length()。

❷public StringBuffer deleteCharAt(intindex)

移除此序列指定位置处的char，此序列的长度将减1。如果传入的索引异常，则发生字符串角标越界异常。

④StringBuffer类的方法：获取

❶public char charAt(int index)

返回此序列中指定索引处的char值，参照数组的索引规则。当传入的索引异常时，发生角标越界异常。

❷public int indexOf(String str)

返回第一次出现的，指定子串在该序列中的索引。若存在，则返回子串第一个字符的索引；否则，返回-1。当str为null时，抛出空指针异常。

❸public int lastIndexOf(Stringstr)

返回最右边(反向查找)出现的，指定子串在此序列中的索引。将最右边的空字符串“”视为出现在索引值this.length()处。若存在，则返回该子串第一个字符的索引；否则，返回-1。当str为null时，抛出空指针异常。

❹public int length()

返回此对象的当前字符序列的长度。

❺public String substring(intstart)

返回一个新的String对象，它包含此序列的字符子串。该子串始于指定索引处的字符，一直到此序列的结尾。

start：起始索引(包含)

如果传入的start异常，则抛出字符串角标越界异常。

❻public String substring(intstart，int end)

返回一个新的String对象，它包含此序列的字符子串。该子串从指定的start处开始，一直到end-1处结束的所有字符。

start：起始索引(包含)

end：结束索引(不包含)

若传入的start和end有一个发生异常，则抛出字符串角标越界异常。

⑤StringBuffer类的方法：修改

❶public StringBufferreplace(int start，int end，String str)/*[ri'pleis]替换*/

使用传入的String中的字符替换此序列的字符子串。该子串是从指定的start处开始，一直到end-1处结束的所有字符。先将其子串中的字符移除，再将传入的String插入start处。

start：起始索引(包含)

end：结束索引(不包含)

str：传入的字符串

如果传入的索引异常，则抛出字符串角标越界异常。

❷public void setCharAt(intindex，char ch)

将此序列的给定索引处的字符替换成字符ch。此序列将被转换，以表示等同于原序列的新序列。当传入的index异常时，抛出角标越界异常。

⑥StringBuffer类的方法：反转

public StringBuffer reverse()/*[ri'və:s]反转*/

将此字符序列用其反转的形式取代。

⑦StringBuffer类的方法：传值

public void getChars(int srcBegin，int srcEnd，char[] dst，int dstBegin)

将此序列被指定的子串中的字符，按索引顺序复制到给定的字符数组中，从给定字符数组的指定索引处存放。原字符数组中的元素将被覆盖掉。

srcBegin：从该序列的此偏移量处开始复制(包含)

srcEnd：在该序列的此偏移量处停止复制(不包含)

dst：用来保存复制数据的数组

dstBegin：字符数组中的偏移量(角标位)

如果dst为null，抛出空指针异常。

如果传入的角标有一个出现异常，则抛出角标越界异常。

 

三、StringBuilder/*['bildə]建造者*/类

public final class StringBuilder

extends Object

implements Serializable，CharSequence

①StringBuilder是一个可变的字符序列。此类提供了一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区只被单个线程使用的时候。

②如果可能，建议在开发时优先采用此类。因为在大多数实现中，它比StringBuffer要快。

③在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效的将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串生成器中。append方法始终将这些字符添加到生成器的末端，而insert方法则在指定的点添加字符。

④Java升级的三个因素：提高效率；简化书写；提高安全性。

⑤StringBuffer与StringBuilder的区别：

StringBuffer：多线程时安全，执行效率较低(每次操作都要判断锁)。

StringBuilder：多线程时不安全，执行效率较高(没有锁，适用于单线程)。也可以用于多线程，通过自定义锁来保证同步，就可以解决安全问题。

⑥StringBuilder与StringBuffer在功能上是一致的，调用方法相同。

⑦从1.5版本开始。

 

四、基本数据类型对象包装类

①概述

❶基本数据类型和其所对应的对象包装类

基本数据类型

对象包装类

byte

Byte

short

Short

int

Integer['intidʒə]

long

Long

boolean

Boolean

float

Float

double

Double

char

Character['kærəktə]

❷基本数据类型对象包装类的最常见的作用是：用于基本数据类型和字符串之间的转换。

基本数据类型转成字符串：

基本数据类型+“”//最简单的转换方式

基本数据类型.toString(基本数据类型值)//最专业的转换方式

例如：Integer.toString(34)；//表示将34整数变成字符串“34”。

字符串转成基本数据类型：

xxx a = Xxx.parseXxx(String)；/*[pa:z]解析*/

int a = Integer.parseInt(“123”)；//将字符串“123”转换成整数123。

double d = Double.paresDouble(“12.3”)；

对于Character类，没有将字符串转换成字符的方法。其对象本身就是字符类型，拥有直接对字符操作的一些方法，如大小写转换。

②Integer类

public final class Integer

extends Number

implements Comparable<Integer>/*['kʌmprəbl]可比较的*/

Integer类在对象中包装了一个基本类型int的值。该类提供了多个方法，能在int类型和String类型之间互相转换，以及一些处理int类型的非常有用的常量和方法。

❶常量字段

public static final int MAX_VALUE

表示int类型的最大值。

public static final int MIN_VALUE

表示int类型的最小值。

❷构造函数

public Integer(int value)

构造一个新的Integer对象，它表示指定的int值。

public Integer(String s)

throws NumberFormatException/*['fɔ:mæt]格式*/

构造一个新的Integer对象 ，它表示String参数所指示的int值。使用了与parseInt/*[pa:z]解析*/方法(对基数为10的值)相同的方式，将该子串转换成int值。

如果传入的String对象，包含不可解析为整数的字符，抛出数字格式异常。

❸将字符串转换为整数

public static int parseInt(String s)

throws NumberFormatException

将传入的字符串解析为十进制形式的整数。除了第一个字符可以是‘-’(负号)之外，字符串中的其它字符都必须是十进制的数字。否则，抛出数字格式异常。

public static int parseInt(String s，int radix)/*['rædiks;'rediks]基数*/

throws NumberFormatException

使用第二参数指定的基数，将字符串参数解析为有符号的整数。除了第一个字符可以是‘-’(负号)之外，字符串中的其它字符都必须是指定基数进制的数字或字母。否则，抛出数字格式异常。

❹十进制数字转换成其它进制的字符串形式

public static String toBinaryString(int i)

以二进制无符号整数形式返回一个整数参数的字符串表示形式。

public static String toOctalString(int i)/*['ɔktl]八进制的*/

以八进制无符号整数形式返回一个整数参数的字符串表示形式。

public static String toHexString(int i)/*['heks]十六进制*/

以十六进制无符号整数形式返回一个整数参数的字符串表示形式。

public static String toString(int i)

返回一个表示指定整数的String对象。将该参数转换为有符号的十进制表示形式，以字符串的形式返回它。如果参数为负数，则结果第一位是‘-’，其它则没有符号。

public static String toString(int i，int radix)

返回用第二个参数指定基数表示的，第一个参数的字符串表示形式。如果第一个参数为负数，则结果第一位是‘-’，其它则没有符号。

❺将Integer对象转换为十进制整数

public int intValue()

以int类型的十进制的表现形式返回该Integer的值，数值有符号。

❻比较方法的覆盖

public boolean equals(Object obj)

比较此对象与指定的对象。当且仅当参数不为null，并且是一个与该对象包含相同int值的Integer对象时，结果为true。否则，返回false。

❼1.5版本新特性

第一个：

Integer x = new Integer(4)；

Integer x = 4；//此处的4等同于new Integer(4)；自动装箱

x = x+2；//引用型和基本型可以直接运算，自动拆箱并装箱

此处x有取值为null的可能，参与运算前要先判断。

第二个：

Integer m = 127；

Integer n = 127；

m==n：结果为true。这里的m和n指向了同一个对象。

原因是：当数值在byte范围内时，对于新特性，如果该数值已经存在，则不会再开辟新的空间。

③其它基本数据对象包装类参阅API。

---------------------------------------- JavaEE+云物联、期待与您交流！---------------------------------------------