簡單敘述:
一、Java基本類型
Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字符類型，還有一種布爾型。
1、整數：包括int,short,byte,long ,初始值爲0
2、浮點型：float,double ,初始值爲0.0
3、字符：char ,初始值爲空格，即'' "，如果輸出，在Console上是看不到效果的。
4、布爾：boolean ,初始值爲false
二、包裝類
包裝類把基本類型轉換爲對象，每個基本類型在java.lang包中都有一個相應的包裝類
包裝類型： Integer 、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger、BigDecmail
其中BigInteger、BigDecimal沒有相對應的基本類型，主要應用於高精度的運算，BigInteger 支持任意精度的整數，BigDecimal支持任意精度帶小數點的運算，主要用於金錢的計算上。
三、包裝類型的作用
3.1提供以下列使用的方法
3.2集合不允許存放基本數據類型數據，存放數字時，要用包裝類型
四、基本類型和包裝類的異同
4.1 在Java中，一切皆對象，但八大基本類型卻不是對象。
4.2聲明方式的不同，基本類型無需通過new關鍵字來創建，而封裝類型需new關鍵字。
4.3存儲方式及位置的不同，基本類型是直接存儲變量的值保存在堆棧中能高效的存取，
封裝類型需要通過引用指向實例，具體的實例保存在堆中。
4.4初始值的不同，封裝類型的初始值爲null，基本類型的的初始值視具體的類型而定，
比如int類型的初始值爲0，boolean類型爲false；
4.5使用方式的不同：如與集合類合作使用時只能使用包裝類型
一、Java 中有8種基本數據類型，如下：
- 整數類型有三種表示形式，分別是十進制、八進制（以0開頭）、十六進制（以0X或者0x開頭）。
![]()
- 對於long型的數值，如果值大於int型數值最大值或者小於int型數值的最小值時，應該在數值的末尾加上L或者l（小寫的L），來表示該數值是long型的。如long num=2147483650L;
![]()
- 默認情況下，Java中的小數都是double型的，若要聲明一個小數是float型的，則需要在數值的末尾加上F或者f，注意，必須要加F或者f，否則會出錯。如float num=12.34F;
-
數據類型
內存空間
取值範圍
char
16位
單引號括住的單個字符(可以表示Unicode表中的所有字符，Unicode表涵蓋了幾乎所有國家所有語言的所有字符)
boolean
位
{true，false}
- char ch=’a’;
- char ch=97;//這兩個式子等價，其中97是字母a在Unicode表中的排序位置，取值範圍爲0~65535(十進制)，也即0x0000~0xffff(十六進制)
- Unicode編碼表中共有65535個字符，涵蓋了幾乎所有國家的所有語言所涉及的符號，各個符號在Unicode表中的位置依次對應於0x0000~0xffff。可以直接使用‘字符’或者字符在Unicode表中的位置表示某個字符，這兩種表示方式是等價的。
![]()
- int型數值和char型數值之間可以進行類型轉換，如上述例子。
- Java中還有一些轉義字符，轉義字符是以反斜線’\’開頭，後跟一個或多個字符。轉義字符具有特定的含義，不同於字符原有的意義，故稱“轉義”。
![]()
![]()
-
小結：關於char型變量
- char型變量可以被賦值成單引號括住的單個字符（字符可以爲Unicode表中的任意一個字符）
- char型變量可以被賦值成Unicode表中的字符所對應位置下標值
- char型變量可以被賦值成轉義字符
二、八種基本數據類型對應的包裝類
2.1概述
- Java不僅支持上述8種基本數據類型，還爲這8種基本數據類型提供了對應的包裝類，通過這些包裝類，我們就可以將上述基本數據類型當做Java中的類對象來處理了。值得說明的是，Java程序中可以直接操作基本數據類型，但是某些情況下需要將它們看成對象來處理，這些情況下就需要藉助於Java API中基本數據類型對應的包裝類來處理了。
-
![]()
- 這些類都在java.lang包中
- 每個類都分別包裝了一種基本的數據類型，如Integer類中包裝了int型變量。除此之外，還要知道這些類中所定義的static final常量，要知道這些常量的意義並且學會如何使用這些靜態常量，如Integer類中定義的一些靜態常量可以直接調用：
//2)Integer類中的靜態成員常量，可以使用Integer.常量名 來操作 System.out.println("java.lang.Integer類中的成員變量："); System.out.println("Integer.MIN_VALUE="+Integer.MIN_VALUE);//結果：-2147483648 System.out.println("Integer.MAX_VALUE="+Integer.MAX_VALUE);//結果：2147483647 System.out.println("Integer.TYPE="+Integer.TYPE);//結果：int - 要了解這些類的構造函數，從而知道該如何通過其構造函數獲得類對象，如Integer類中構造函數有兩個，分別是Integer(int num)和Integer(String num),那麼我們就這樣獲得Integer對象：
Integer integer=new Integer(23); Integer integer2=new Integer(“123”); - 除了要了解上述各個類的構造函數來獲取相應類對象之外，還要學習上述各個類中的成員方法，從而使用相應的成員方法作出更多的操作。如Integer類中，有如下常用成員方法：
![]()
2.2各個包裝類的詳細情況
- 概述：見eclipse中JavaTest工程下datatype包中的程序文件
-
- 基本數據類型的各個包裝類的用法舉例：（即上述JavaAPI_Boolean.java JavaAPI_Byte.java ......）
-
-
JavaAPI_Boolean.java/** * @author lxrm * @date 20170130 * @description 講述Java API之java.lang.Boolean類的用法 * java.lang.Boolean * 1）概述：該類對應於8種基本數據類型中的boolean，類中包含了若干用於處理boolean型數值以及變量的方法 * 這個類封裝了boolean這種基本數據類型，當需要將boolean看做類對象來處理時，可以藉助於該類進行相應操作 * Boolean類中包含若干將boolean型數值轉變成String類型的成員方法， * 以及若干將String類型數值轉變成boolean型數值的方法 * 以及其他處理boolean型變量的成員方法（如 比較大小，boolean型數值的二進制表示形式進行左移右移、反轉等） * 2）Boolean類中的靜態成員常量（static類型的成員常量） * TRUE:Boolean TRUE是一個Boolean對象,且該Boolean對象對應的基值是true * FALSE:Boolean FALSE是一個Boolean對象，且該Boolean對象對應的基值是false * TYPE:Class<Boolean> Boolean類所對應的原始基本數據類型，其值爲"boolean" * * 3)Boolean類中的構造函數(用於生成Boolean對象) * 3.1)public Boolean(boolean value) * 3.2)public Boolean(String s) * 備註：當s="true"(不區分大小寫)時，生成的Boolean對象代表true * s="任何其他字符串"，生成的Boolean對象都代表false * 4)Boolean類中的成員函數 * 4.1）靜態成員函數 * （string--->boolean數值） * 4.1.1）public static boolean parseBoolean(String s) * 功能：將String對象解析成boolean型數值 * 返回值：是一個boolean型數值， * 當s:String="true"(不區分大小寫)時，返回值是true * 當s:String="其他字符串" 時，返回值是false * （boolean數值--->Boolean對象） * 4.1.2）public static Boolean valueOf(boolean b) * （String--->Boolean對象） * 4.1.3）public static Boolean valueOf(String s) * 返回值：是一個Boolean對象 * 當s:String="true"(不區分大小寫)時，返回值是代表true的Boolean對象 * 當s:String="其他字符串" 時，返回值是代表false的Boolean對象 * （boolean--->String對象） * 4.1.4）public static String toString(boolean b) * 返回值：如果b:boolean=true,那麼返回值是字符串“true” * 如果b:boolean=false,那麼返回值是字符串“false” * （系統屬性(即java.lang.System#getProperty(String name))---->boolean） * 4.1.5） public static boolean getBoolean(String name) * @param name the system property name. * 返回值：只有系統屬性name的值=="true"時，返回值是true * （比較兩個boolean變量的值） * 4.1.6）public static int compare(boolean x, boolean y) * @return the value {@code 0} if {@code x == y}; * a value less than {@code 0} if {@code !x && y}; and * a value greater than {@code 0} if {@code x && !y} * 4.2）實例成員函數 * 4.2.1）public boolean booleanValue() * 功能：返回Boolean對象的boolean值 * 4.2.2）public String toString() * 返回值：如果b:boolean=true,那麼返回值是字符串“true” * 如果b:boolean=false,那麼返回值是字符串“false” * 4.2.3）public int hashCode() * 返回值：如果b:boolean=true,那麼返回值是int型數值1231 * 如果b:boolean=false,那麼返回值是int型數值1237 * 4.2.4） public boolean equals(Object obj) * 4.2.5）public int compareTo(Boolean b) * @return zero if this object represents the same boolean value as the * argument; a positive value if this object represents true * and the argument represents false; and a negative value if * this object represents false and the argument represents true * */ package datatype; public class JavaAPI_Boolean { public static void main(String[] args){ //使用Boolean類中的構造函數來創建Boolean類對象 Boolean b1=new Boolean(true);//生成了一個代表true的Boolean對象 Boolean b2=new Boolean("ok");//生成了一個代表false的Boolean對象 Boolean b3=new Boolean("tRue");//生成了一個代表true的Boolean對象 } } -
JavaAPI_Byte.java/** * @author lxrm * @date 20170131 * @description 講述Java API之java.lang.Byte類的用法 * java.lang.Byte * 1）概述：該類對應於8種基本數據類型中的byte，類中包含了若干用於處理byte型數值以及變量的方法 * 這個類封裝了byte這種基本數據類型，當需要將byte看做類對象來處理時，可以藉助於該類進行相應操作 * Byte類中包含若干將byte型數值轉變成String類型的成員方法， * 以及若干將String類型數值轉變成byte型數值的方法 * 以及其他處理byte型變量的成員方法（如 比較大小，byte型數值的二進制表示形式進行左移右移、反轉等） * 2）Byte類中的靜態成員常量（static類型的成員常量） * MIN_VALUE：byte 表示byte型變量可以取到的最小值-2^7=-128 * MAX_VALUE:byte 表示byte型變量可以取到的最大值2^7-1=127 * TYPE:Class<Byte> byte類所對應的原始基本數據類型，其值爲"byte" * SIZE:int 表示byte型數值所佔內存大小，單位爲bit * * 3)Byte類中的構造函數(用於生成Byte類對象) * 3.1）public Byte(byte value) * 3.2） public Byte(String s) throws NumberFormatException * 備註：參數s:String必須是十進制形式的byte數值 * * 4)Byte類中的成員函數 * 4.1）靜態成員函數 * （byte類型數值--->String（十進制形式）） * 4.1.1)public static String toString(byte b) * 功能：將b:byte轉化成string（十進制形式的string）並返回 * （byte類型數值--->Byte類對象） * 4.1.2）public static Byte valueOf(byte b) * 功能：將b:byte封裝成Byte類對象並返回 * 使用這個成員方法將byte數值封裝成Byte對象比用Byte類的構造函數Byte(byte b)來獲取Byte對象效果更好 * 因爲這個成員函數擁有更好的空間利用率，也更快 * （將各種進制形式2/8/10/16..的string--->byte型數值） * 4.1.3）public static byte parseByte(String s, int radix)throws NumberFormatException * 功能：將radix進制的string解析成byte型數值 * public static byte parseByte(String s) throws NumberFormatException * 功能：將10進制的string解析成byte數值 * （將各種進制形式2/8/10/16..的string--->Byte類對象） * 4.1.4）public static Byte valueOf(String s, int radix) * 功能：將radix進制的string解析成Byte類對象 * public static Byte valueOf(String s) throws NumberFormatException * 功能：將10進制的string解析成Byte類對象 * public static Byte decode(String nm)throws NumberFormatException * 功能：將8/10/16進制的string解析成Byte對象，這個函數與上述兩個函數有點區別：這個函數比上述兩個函數更加智能化， * 因爲這個函數能自動識別string的表示形式是幾進制的，不用編程人員手動識別待解析string是幾進制的 * nm:String是以“0x/0X/#”開頭的時候，該函數認爲nm:string是十六進制的 * nm：String是以“0”開頭的時候，該函數認爲nm:String是八進制的 * 其他情況下，認爲是十進制的 * 除此之外，該函數還能自動識別nm:String中的正負號 * * 4.2）實例成員函數 * （Byte對象所代表的byte型數值--->byte、short、int、long、float、double型數值） * 4.2.1） public byte byteValue() * public short shortValue() * public int intValue() * public long longValue() * public float floatValue() * public double doubleValue() * （Byte對象所代表的byte型數值--->String型數值） * 4.2.3）public String toString() * （Byte對象所代表的byte型數值--->hashCode） * 4.2.4）public int hashCode() * （比較兩個Long對象的大小） * 4.2.5）public boolean equals(Object obj) * 4.2.6）public int compareTo(Byte anotherByte) * 4.2.7）靜態函數，可直接調用public static int compare(byte x, byte y) */ package datatype; public class JavaAPI_Byte { public static void main(String[] args){ System.out.println("java.lang.Byte類用法示例："); //2）Byte類中的靜態成員常量 System.out.println("\nByte類中的靜態成員常量public static final vectorName=value;"); System.out.println("Byte.MIN_VALUE="+Byte.MIN_VALUE); System.out.println("Byte.MAX_VALUE="+Byte.MAX_VALUE); System.out.println("Byte.Type="+Byte.TYPE); System.out.println("Byte.SIZE="+Byte.SIZE); //3）使用Byte類的構造函數獲得Byte類對象，然後使用Byte類對象調用Byte類中的實例成員函數 byte param=34;//byte就是一個8位的整數（注意他的取值範圍即可） Byte b=new Byte(param); //第二種構造函數 Byte b2=new Byte("127");//一定要注意取值範圍哦，byte型變量的取值範圍爲-128~127 } } -
JavaAPI_Integer.java -
/** * @author lxrm * @date 20170129 * @description 講述Java API之java.lang.Integer類的用法 * java.lang.Integer * 1）概述，這個類封裝了int這種基本數據類型，當需要將int看做類對象來處理時，可以藉助於該類進行相應操作 * Integer類中包含若干將int型數值轉變成string類型的成員方法， * 以及若干將string類型數值轉變成int型數值的方法 * 以及其他處理int型變量的成員方法（如比較大小，int值的二進制表示形式進行左移右移、反轉等） * 2）Integer類中的靜態成員常量（static類型的成員常量） * MIN_VALUE:int int型變量可以表示的最小值-2^31 * MAX_VALUE:int int型變量可以表示的最大值2^31-1 * TYPE:Class<Integer> Integer類所對應的原始基本數據類型，其值爲"int" * (不常用) digits:char[] 字符串可以表示數值，如“123”表示數值123，但是字符串中的字符不能隨便取值。 * 用於表示數值的字符串中的字符只能取自digits字符數組中的元素，即{0-9，a-z} * public static final int SIZE = 32;//int型數值所佔內存大小，單位爲bit * * 3）Integer類中的構造函數 * public Integer(int value) * public Integer(String s) throws NumberFormatException * 備註：s:String必須是一個十進制形式的數值，否則會拋出NumberFormatException * 4）Integer類中的成員方法 * 概述：這些成員函數的功能就是使得2/8/10/16進制的String對象<----->10進制形式的int型數值<----->10進制形式的Integer對象 * <----->byte/short/int/long/float/double類型<----->hash碼 * 之間可以相互轉化 * 還有一些成員函數用於比較兩個Integer對象,或者比較兩個int值 * 某些成員方法可以訪問int型數值的最高、最低bit處的值，int型數值的二進制表示法中0的個數 * 將int型數值的二進制表示形式左移或者右移若干bit位得到一個新的值 * 4.1)靜態成員方法（直接使用Integer.方法名（）來調用） * 4.1.1)public static String toString(int i, int radix) * 功能：將int型的數值轉換成String對象，並且可以指定表示形式（10進制、八進制、十六進制） * 參數：i:int 待轉換的int型變量 * radix:int 數值的表示形式，其值可以爲10,8,16 * 返回值：String int型參數i轉化後的結果，是一個String對象 * 備註：如果需要將字母轉換成大寫的，可以結合使用toUpperCase()使用， * {@code Integer.toString(n,radix).toUpperCase()} * public static String toString(int i) * 備註：這個函數和上述函數功能相似，只不過這個函數默認使用10進製表示，即該函數等價於Integer.toString(n,10) * 4.1.2) public static String toHexString(int i) * 功能：將int型的數值轉換成String對象,但是隻能使用16進製表示 * 除此之外，轉化結果不一定等於原來的值，而是對應於原有int值的一個無符號整數，具體解釋爲： * 如果原來的值是負值，則結果=原來的值+2^32 * 如果原來的值是正的，則結果=原來的值 * 參數：i:int 待轉化的int型數值 * 返回值：轉化後的結果，即參數i:int所對應的無符號整數 * public static String toOctalString(int i) * public static String toBinaryString(int i) * 備註：後面這倆個成員函數和前面所述函數功能相似，都是把有符號int型變量值轉換成無符號整數值（原先是正數時轉換結果等於原來的值， * 原先爲負數時等於原先的值+2^32）,再將轉化所得無符號數值轉化成String對象，只不過第一個函數是表示成16進制形式， * toOctalString()是表示成八進制形式，toBinaryString()是表示成二進制形式 * 4.1.3）public static int parseInt(String s, int radix) throws NumberFormatException * 功能：將String對象轉化成int型數值，前提是該String對象表示的是一個數值（即該string對象中的字符只能包含對應進制下的字符） * 參數：s:String 待轉化的字符串，如“-123” “87ab1” * radix:int 表示參數s:String值的表示形式，可取的值有2/8/10/16，分別表示s:String是二進制/八進制/十進制/十六進制數值 * 返回值：int 參數s:String對應的int值（以10進制形式表示） * 異常：當參數s:String,即待轉化字符串中含有對應進制下不該出現的字符時，拋出NumberFormatException * 如Integer.parseInt("34ae5h",16)就是錯的，會觸發異常，因爲16進制下不應該出現h字符 * public static int parseInt(String s) throws NumberFormatException * 備註：這個函數和上述函數功能相似，只不過默認string參數的表示形式是十進制的，這個函數等效於Integer.parseInt(String s,10) * 4.1.4）public static Integer valueOf(String s, int radix) throws NumberFormatException * 功能：和4.1.3）小結中所陳列的函數功能相似，只不過這裏是轉化成Integer對象，而4.1.3小結中函數是轉化成int型數值 * 也就是說本函數的功能是將8/10/16進制的String轉化成十進制形式的Integer對象 * public static Integer valueOf(String s) throws NumberFormatException * 備註：和上述函數功能相似，只不過本函數默認s:String是以十進制形式表示的 * 4.1.5）public static Integer valueOf(int i) * 功能:將int型數值轉化成Integer對象 * 4.1.6）public static Integer getInteger(String nm) * 功能：獲取系統屬性（即java.lang.System#getProperty(java.lang.String)） * 並將該“系統屬性”的值轉化成Integer對象返回 * 參數：nm:String=java.lang.System#getProperty(java.lang.String) * 返回值：Integer對象，是系統屬性值轉化而來的 * public static Integer getInteger(String nm, int val) * 備註：和上述函數功能相似，只不過這個函數添加了一個參數val:int,使用這個參數給系統屬性賦了一個默認值，當系統屬性nm:String的值爲空時， * 系統屬性nm不存在，或者系統屬性值中含有不能解析爲數字的字符時 * val的值就作爲int數值，封裝成Integer對象 * @param nm property name.系統屬性的 屬性名稱 * @param val default value.默認值，當相應系統屬性的值爲空時或者不能解析成數值，或者該系統屬性根本不存在時，該參數起作用，被作爲int數值封裝成Integer對象 * @return the {@code Integer} value of the property.將系統屬性的值封裝成Integer對象 * public static Integer getInteger(String nm, Integer val) * 備註：和上述第二個函數功能相同，只不過默認值不是int型的，而是直接是一個Integer對象 * 4.1.7）public static Integer decode(String nm) throws NumberFormatException * 功能：將String對象的值解析成Integer對象（能夠根據字符串首字母知道這個字符串的表示形式是幾進制） * 參數：nm:String 待解析的字符串，如果nm="0x..."或者"0X..."或者"#...",程序會認爲該字符串是16進制的 * 如果nm="0...",程序會認爲該字符串是8進制的 * 除了上述四種情況之外，程序都會認爲該字符串是十進制的 * 4.1.8）public static int compare(int x, int y) * @param x the first {@code int} to compare * @param y the second {@code int} to compare * @return the value {@code 0} if {@code x == y}; * a value less than {@code 0} if {@code x < y}; and * a value greater than {@code 0} if {@code x > y} * 4.1.9）public static int highestOneBit(int i) * 功能：返回int型數值的最高bit位的值 * public static int lowestOneBit(int i) * 功能：返回i:int的最低bit位的值 * public static int numberOfLeadingZeros(int i) * （不知理解的是否正確）功能：返回i:int的二進制表示法中0的個數（從最高位開始） * public static int numberOfTrailingZeros(int i) * （不知理解的是否正確）功能：返回i:int的二進制表示法中0的個數（從最低位開始） * public static int bitCount(int i) * （不知理解的是否正確）功能：返回i:int的二進制表示法中１的個數 * 4.1.10）public static int rotateLeft(int i, int distance) * 功能：將i:int的二進制表示形式左移distance位，得到一個新的值並返回 * public static int rotateRight(int i, int distance) * public static int reverse(int i) * public static int reverseBytes(int i) * 4.1.11） public static int signum(int i) * 功能：判斷int數值的符號，如果是0，返回值爲0；如果是正數，返回值是1；如果是負數，返回值是-1 * 4.2)實例成員方法，不可直接使用類名.方法名()直接調用下面的函數，只能先得到一個Integer實例，然後用該實例調用下面的這些非static成員方法 * 4.2.1）public byte byteValue() * 功能:將Integer對象代表的value變成byte類型並返回 * public short shortValue() * public int intValue() * public long longValue() * public float floatValue() * public double doubleValue() * 4.2.2）public String toString() * 功能：將Integer對象所代表的數值轉化成10進制形式的String對象 * 4.2.3）public int hashCode() * 功能：將Integer對象所代表的數值轉化成hash碼 * 4.2.4） public boolean equals(Object obj) * 功能：只有參數是Integer類型並且其值與被比較者所代表的int數值相等時，返回值爲true * 4.2.5）public int compareTo(Integer anotherInteger) * 功能：比較兩個Integer對象的數值的大小，如果相等，則返回值=0 * 如果比參數小，則返回值爲一個負數 * 如果比參數大，則返回值爲一個正數 * * * * */ package datatype; public class JavaAPI_Integer { public static void main(String[] args){ //2)Integer類中的靜態成員常量，可以使用Integer.常量名 來操作 System.out.println("java.lang.Integer類中的成員變量："); System.out.println("Integer.MIN_VALUE="+Integer.MIN_VALUE);//結果：-2147483648 System.out.println("Integer.MAX_VALUE="+Integer.MAX_VALUE);//結果：2147483647 System.out.println("Integer.TYPE="+Integer.TYPE);//結果：int //4.1）靜態成員方法 //4.1.1）十進制形式的int型數值轉化成2/8/10/16進制形式的String對象（保留原有符號） System.out.println("\n有符號int型數值轉換成String對象（保留原來數值符號）："); System.out.println("1）Integer.toString(int i,int radix)用法示例："); System.out.println("Integer.toString(-123, 10) "+Integer.toString(-123, 10));//結果：“-123” System.out.println("Integer.toString(-123, 8) "+Integer.toString(-123, 8));//結果：“-173” System.out.println("Integer.toString(-123, 2) "+Integer.toString(-123, 2));//結果：“-1111011” System.out.println("Integer.toString(-123, 16) "+Integer.toString(-123, 16));//結果：“-7b” System.out.println("Integer.toString(123, 16) "+Integer.toString(123, 16));//結果：“7b” System.out.println("Integer.toString(123, 16).toUpperCase() "+Integer.toString(123, 16).toUpperCase());//結果：“7B” System.out.println("2）Integer.toString(int i)用法示例："); System.out.println("Integer.toString(-123) "+Integer.toString(-123));//結果：“-123” System.out.println("小結：Integer.toString(int i)等效於Integer.toString(int i,10),即，默認使用十進制形式表示"); //4.1.2）十進制形式的int型數值轉化成無符號整數，再轉化成2/8/16String對象（正數數值不變，負數數值變成原有值+2^32） System.out.println("\n有符號int型數值轉換成無符號類型整數，再轉化成String對象（負數變成正數，正數還是正數）："); System.out.println("1）Integer.toHexString(int i)的用法示例："); System.out.println("Integer.toHexString(-123) "+Integer.toHexString(-123));//結果：“ffff ff85” System.out.println("Integer.toHexString(123)"+Integer.toHexString(123));//結果："7b" System.out.println("2）Integer.toOctalString(int i)的用法示例："); System.out.println("Integer.toOctalString(-123) "+Integer.toOctalString(-123));//結果："37777777605" System.out.println("Integer.toOctalString(123) "+Integer.toOctalString(123));//結果："173" System.out.println("3）Integer.toBinaryString(int i)的用法示例："); System.out.println("Integer.toBinaryString(-123) "+Integer.toBinaryString(-123));//結果："11111111111111111111111110000101 System.out.println("Integer.toBinaryString(123) "+Integer.toBinaryString(123));//結果："1111011" //4.1.3)將2/8/10/16進制的String對象解析成int型數值（10進制形式的int值） System.out.println("\n將String類型對象轉換成int類型數值（前提是你的String對象必須是一個數值）"); System.out.println("1）Integer.toPerseInt(String str,int radix)的用法示例："); System.out.println("Integer.toPerseInt(\"0010100011\",2) "+Integer.parseInt("0010100011",2));//結果:163 System.out.println("Integer.toPerseInt(\"137\",8) "+Integer.parseInt("137",8));//結果：95 System.out.println("Integer.toPerseInt(\"123\",10) "+Integer.parseInt("123",10));//結果:123 System.out.println("Integer.toPerseInt(\"1fe2\",16) "+Integer.parseInt("1fe2",16));//結果：8162 System.out.println("Integer.toPerseInt(\"-1fe2\",16) "+Integer.parseInt("-1fe2",16));//結果：-8162 System.out.println("2）Integer.toPerseInt(String str)的用法示例："); System.out.println("Integer.toPerseInt(\"-123\") "+Integer.parseInt("-123")); System.out.println("總結：Integer.toPerseInt(String str)等效於Integer.toPerseInt(String str，10)"); } } -
JavaAPI_Long.java/** * @author lxrm * @date 20170130 * @description 講述Java API之java.lang.Long類的用法 * java.lang.Long * 1）概述：該類對應於8種基本數據類型中的long，類中包含了若干用於處理long型數值以及變量的方法 * 這個類封裝了long這種基本數據類型，當需要將long看做類對象來處理時，可以藉助於該類進行相應操作 * Long類中包含若干將long型數值轉變成string類型的成員方法， * 以及若干將string類型數值轉變成long型數值的方法 * 以及其他處理long型變量的成員方法（如 比較大小，long型數值的二進制表示形式進行左移右移、反轉等） * 2）Long類中的靜態成員常量（static類型的成員常量） * MIN_VALUE:long long型變量可以表示的最小值-2^63 * MAX_VALUE:long long型變量可以表示的最大值2^63-1 * TYPE:Class<Long> Long類所對應的原始基本數據類型，其值爲"long" * SIZE:int long型數據所佔內存大小，其值爲64bit * 3)Long類中的構造函數 * 3.1）public Long(long value) * 3.2）public Long(String s) throws NumberFormatException * 備註：s:String必須是十進制的long型數值 * s：String只能包含十進制數值應該含有的字符，否則會觸發異常 * s:String 不需要 以l/L作爲結束標誌來表明這是long型數值 * 4）Long類中的成員函數 * 綜述：Long類中有若干成員函數，這些成員函數可以被分成若干類 * 第一類用於實現各種進制的String對象與Long對象、long型數值之間的轉換 * 第二類成員函數用於將Long對象所包含的long型數值轉化成byte、short、int、long、float、double、string、hashCode * 第三類成員函數用於比較倆個Long對象或者long型數值的大小 * 第四類成員函數用於操作long型數值的bit位（如最高、最低bit位，左移右移，反轉，0的個數，1的個數等） * 用於判斷long型數值的符號（即正負） * 4.1）Long類中的靜態成員函數（static成員函數） *(有符號10進制形式的long型數值-->2/8/10/16進制形式的有符號String對象) * 4.1.1)public static String toString(long i, int radix) * 功能：將long型的數值轉化成2/8/10/16進製表示的字符串,保留原有符號 * @param i:long a {@code long} to be converted to a string.待轉換的long型數值 * @param radix:int the radix to use in the string representation.指明你想要將你的long型數值轉化成幾進制的字符串 * @return String a string representation of the argument in the specified radix. 2/8/10/16進製表示的字符串 * 調用方法： * {@code Long.toString(n，radix).toUpperCase()}大寫形式 * {@code Long.toString(n，radix)}小寫形式 * public static String toString(long i) * 備註：這個函數的功能和上述函數功能相似，只不過這個函數只能將其轉化成10進制形式的字符串（保留原有long型數值的正負號） * 這個函數等效於上述函數中將radix賦值爲10的情況 * 即{@code Long.toString(long i)=Long.toString(long i,10)} *(有符號10進制形式的long型數值-->無符號十進制形式的long型數值-->2/8/16進制形式的無符號String對象) * 4.1.2） public static String toHexString(long i) * 功能：將10進製表示的有符號long型數值轉化成10進製表示的無符號long型數值，然後將無符號long型數值轉化成十六進制表示的字符串 * 如果原有long型數值是正的，那麼對應的無符號long型數值=原來的值 * 如果原有long型數值是負的，那麼對應的無符號long型數值=原來的值+2^64 * @param i:long a {@code long} to be converted to a string. * @return String the string representation of the unsigned {@code long} * value represented by the argument in hexadecimal十六進制 * (base 16). * 調用方法： * {@code Long.toHexString(n).toUpperCase()}大寫形式 * {@code Long.toHexString(n)}小寫形式 * public static String toOctalString(long i) * public static String toBinaryString(long i) * 備註：這兩個函數和上述第一個函數功能相似，都是先將有符號long型值i轉化成無符號long型數值，然後再將無符號long型數值轉化成字符串， * 唯一的區別在於字符串的表示形式不同，hex是十六進制，octal是八進制，binary是二進制字符串 *(2/8/10/16進制形式的字符串-->十進制形式的long型數值（保留原有正負號）) * 4.1.3）public static long parseLong(String s, int radix) throws NumberFormatException * 功能：將一個2/8/10/16、17/18/19...進制的字符串解析成一個有符號（正負號）的long型數值 * radix指明該字符串的進制，string中不應該含有對應進制之外的字符，譬如radix=8時，如果s:String中含有字符8,9，a之類的字符，那麼程序就會拋出異常 * * @param s the {@code String} containing the * {@code long} representation to be parsed. * s:string 中不應該含有進制之外的字符 * s:String中可以有+ 、- 符號 * s:String中不要用L/l來表示該字符串是long型數值 * @param radix the radix to be used while parsing {@code s}.也即字符串s:String的進制 * @return the {@code long} represented by the string argument in * the specified radix. * @throws NumberFormatException if the string does not contain a * parsable {@code long}. * public static long parseLong(String s) throws NumberFormatException * 備註：和上述函數功能相似，只不過本函數默認string的表示形式是10進制，本函數和上述函數中將radix賦值爲10的效果是一樣的 * 即{@code Long.parseLong(String s)=Long.parseLong(String s,10)} *(2/8/10/16..進制形式的字符串--->Long對象（保留原有正負號）) * 4.1.4） public static Long valueOf(String s, int radix) throws NumberFormatException * 備註：和4.1.3）小節中第一個函數功能相似，只不過有個不同的點，這個函數的返回值是Long對象，二上面的函數的返回值是long型數值 * 即調用這個函數所得到的Long對象和下面的代碼所得到的Long對象是一樣的 * {@code new Long(Long.parseLong(s, radix))} * 等效於 {@code Long.valueOf(s,radix)} * public static Long valueOf(String s) throws NumberFormatException * 備註：和上述函數功能相似，只不過本函數默認s:String是十進制形式的long數值 * 4.1.5）public static Long decode(String nm) throws NumberFormatException * 功能：和4.1.4）小結中所述函數功能相似，也是將字符串轉換成Long對象，只不過這個函數更智能， * 因爲本函數可以自動識別出nm:String的進制，不用在調用程序時顯式地指明string的進制 * nm：String若是以0x/0X/#開頭的，那麼Long.decode(nm)函數認爲nm:String是十六進制的 * nm：String若是以0開頭的，那麼Long.decode(nm)函數認爲nm:String是八進制的 * 除此之外，Long.decode(nm)函數認爲nm:String是十進制的 *（10進制的long型數值--->10進制的Long對象） * 4.1.6）public static Long valueOf(long l) * 功能：將long型數值包裝成Long對象 *（獲得系統屬性的值(即java.lang.System#getProperty(java.lang.String) ),並將其轉化成Long對象） * 4.1.7)public static Long getLong(String nm) * 功能： * 參數：nm:String 系統屬性的名稱 * 返回值：名爲nm:String的系統屬性的值轉化成的Long對象 * public static Long getLong(String nm, long val) * 備註：本函數和上述函數功能相似，只不過本函數多了一個參數val:long,這個參數一般情況下是不起作用的，只有如下幾種情況下會起作用 * 當系統屬性nm不存在或者 if the property does not have the correct numeric format, * or if the specified name is empty or null. * 上述幾種情況下會將參數val:long的值封裝成Long對象並返回 * public static Long getLong(String nm, Long val) * 備註：這個函數和上述第二個函數功能類似，只不過這個函數的第二個參數的類型是一個Long對象，而非long型變量 * 除了上述不同之處，這個函數還有一個特點就是，這個函數能夠自動識別nm:String（系統屬性）的表示形式是幾進制的 * 當nm:string是以“0x/0x/#”開頭的時候，認爲nm是十六進制的 * 當nm:string是以“0”開頭的時候，認爲nm是八進制的 * 其他情況下認爲nm是十進制的 * 另外，無論nm是幾進制的表示形式，都不允許string的末尾以L/l作爲標誌位表明這個string表示的是long型數值，否則會出錯 *（比較兩個long型變量值的大小） * 4.1.8）public static int compare(long x, long y) *（bit位操作） * 4.1.9） public static long highestOneBit(long i) * public static long lowestOneBit(long i) * public static int numberOfLeadingZeros(long i) * public static int numberOfTrailingZeros(long i) * public static int bitCount(long i) * public static long rotateLeft(long i, int distance) * public static long rotateRight(long i, int distance) * public static long reverse(long i) * public static long reverseBytes(long i) * （判斷原有long型數值的符號，即正負） * 4.1.10）public static int signum(long i) * 返回值：當i:long是正數時，返回值爲1；是0時，返回值是0；是負數時，返回值是-1 * 4.2）Long類中的實例成員函數（必須先獲取Long實例，才能調用下面所述各個函數） * （Long對象所代表的long型數值--->byte、short、int、long、float、double型數值） * 4.2.1） public byte byteValue() * public short shortValue() * public int intValue() * public long longValue() * public float floatValue() * public double doubleValue() * （Long對象所代表的long型數值--->String型數值） * 4.2.3）public String toString() * （Long對象所代表的long型數值--->hashCode） * 4.2.4）public int hashCode() * （比較兩個Long對象的大小） * 4.2.5）public boolean equals(Object obj) * 4.2.6）public int compareTo(Long anotherLong) * 4.2.7）靜態函數，可直接調用public static int compare(long x, long y) * * * */ package datatype; public class JavaAPI_Long { public static void main(String[] args){ System.out.println("java.lang.Long類用法示例："); //2）Long類中的靜態成員常量 System.out.println("\nLong類中的靜態成員常量public static final vectorName=value;"); System.out.println("Long.MIN_VALUE="+Long.MIN_VALUE); System.out.println("Long.MAX_VALUE="+Long.MAX_VALUE); System.out.println("Long.Type="+Long.TYPE); System.out.println("Long.SIZE="+Long.SIZE); System.out.println("\nLong類中的靜態成員函數："); //4.1）Long類中的靜態成員函數 //4.1.1）將10進制形式的long型的數值轉化成2/8/10/16進製表示的字符串 System.out.println("============================================"); System.out.println("將10進制形式的long型的數值轉化成2/8/10/16進製表示的字符串-----保留long型數值的原有符號（正負號）"); System.out.println("Long.toString(long i,int radix)函數用法示例"); System.out.println("Long.toString(-123L,2)="+Long.toString(-123L, 2)); System.out.println("Long.toString(-123L,8)="+Long.toString(-123L, 8)); System.out.println("Long.toString(-123L,10)="+Long.toString(-123L, 10)); System.out.println("Long.toString(-123L,16)="+Long.toString(-123L, 16)); System.out.println("---------------------------------------------"); System.out.println("將10進制形式的long型的數值轉化成2/8/10/16進製表示的字符串-----先將待轉化long型數值轉化成無符號long型數值，再轉化成字符串"); System.out.println("Long.toHexString(long i)函數用法示例"); System.out.println("Long.toHexString(-123)="+Long.toHexString(-123)); System.out.println("Long.toOctalString(long i)函數用法示例"); System.out.println("Long.toOctalString(-123)="+Long.toOctalString(-123)); System.out.println("Long.toBinaryString(long i)函數用法示例"); System.out.println("Long.toBinaryString(-123)="+Long.toBinaryString(-123)); //4.1.3)將1/2/3/4..8/10/16/...32....進制的有符號字符串轉化成有符號long型數值 System.out.println("============================================"); System.out.println("將2/8/10/16...23...36..進製表示的字符串轉化成有符號的10進制的long型數值-----保留原有符號（正負號）"); System.out.println("Long.parseLong(String s,int radix)函數的用法："); System.out.println("Long.parseLong(\"1000110\",2)="+Long.parseLong("1000110", 2)); System.out.println("Long.parseLong(\"734100\",8)="+Long.parseLong("734100", 8)); System.out.println("Long.parseLong(\"-1398\",10)="+Long.parseLong("-1398", 10)); System.out.println("Long.parseLong(\"-123afe\",16)="+Long.parseLong("-123afe", 16)); System.out.println("Long.parseLong(\"123ahdlxrm\",36)="+Long.parseLong("123ahdlxrm", 36)); //通過構造函數創建Long對象，並通過Long對象調用Long類中的實例方法 Long l1=new Long(123L); Long l2=new Long("482"); } }![複製代碼]()
-
JavaAPI_Character.java -
/** * @author lxrm * @date 20170131 * @description 講述Java API之java.lang.Character類的用法 * java.lang.Character * 1）概述：該類對應於8種基本數據類型中的char，char是一個16bit的字符變量，char型變量可以表示Unicode編碼表中的所有字符（Unicode表格覆蓋了中文、英文、其他各種語言以及一些特殊符號） * 類中包含了若干用於處理char型數值以及變量的方法 * 這個類封裝了char這種基本數據類型，當需要將char看做類對象來處理時，可以藉助於該類進行相應操作 * Character類中包含若干將char型數值轉變成String類型的成員方法， * 以及若干將String類型數值轉變成char型數值的方法 * 以及其他處理char型變量的成員方法（如 比較大小，char型數值的二進制表示形式進行左移右移、反轉等） * 將char型數值從大寫變小寫，小寫變大寫 * 判斷一個char型值是大寫的還是小寫的，是否是數字，是否是字母 * 2）Character類中的靜態成員常量（static類型的成員常量） * public static final int MIN_RADIX = 2;//以字符串形式表示的char型數值的最小進制數，即最小使用二進制表示 * public static final int MAX_RADIX = 36;//以字符串形式表示的char型數值的最大進制數，即最大使用三十六進制表示 * public static final char MIN_VALUE = '\u0000';//char型變量可以取到的最小值，是0 * public static final char MAX_VALUE = '\uFFFF';//char型變量可以取到的最大值，是2^16-1 * TYPE:Class<Character> char類所對應的原始基本數據類型，其值爲"char" * SIZE:int 表示char型數值所佔內存大小，單位爲bit * public static final byte UNASSIGNED = 0; * public static final byte UPPERCASE_LETTER = 1; * public static final byte LOWERCASE_LETTER = 2; * public static final byte TITLECASE_LETTER = 3; * public static final byte MODIFIER_LETTER = 4; * public static final byte OTHER_LETTER = 5; * public static final byte NON_SPACING_MARK = 6; * public static final byte ENCLOSING_MARK = 7; * public static final byte COMBINING_SPACING_MARK = 8; * ... * ... * * 3)Character類中的構造函數(用於生成Character類對象) * 3.1）public Character(char value) * * * 4)char類中的成員函數 * 4.1）靜態成員函數 * （char類型數值--->String） * 4.1.1) public static String toString(char c) * 功能：將c:char轉換成字符串並返回，返回的字符串長度爲1，只包含字符c:char * （char類型數值--->Character類對象） * 4.1.2）public static Character valueOf(char c) * 功能：將c:char封裝成Character類對象並返回 * 使用這個成員方法將char數值封裝成Character對象比用Character類的構造函數Character(char c)來獲取Character對象效果更好 * 因爲這個成員函數擁有更好的空間利用率，也更快 * （判斷一個codePoint是否是有效的切點） * 4.1.3）public static boolean isValidCodePoint(int codePoint) * @return {@code true} if the specified code point value is between * {@link #MIN_CODE_POINT} and * {@link #MAX_CODE_POINT} inclusive; * {@code false} otherwise. * （判斷char是大寫的還是小寫的） * 4.1.4）public static boolean isLowerCase(char ch) * 返回值：如果ch:char是小寫的，返回值是true，否則返回值是false * public static boolean isLowerCase(int codePoint) * 參數：codePoint：int是待鑑別字符在Unicode表中的位置 * 返回值：如果Unicode表中codePoint處的字母是小寫的，返回值是true，否則返回值是false * 備註：這個函數和上述函數的區別在於，這個函數可以通過codePoint：int訪問到Unicode表格中的所有字符， * 但是上述函數則不能訪問到Unicode表格中的所有字符，因爲ch:char是16bit的， * 所以ch:char只能訪問到Unicode表中上半部分的內容 * public static boolean isUpperCase(char ch) * public static boolean isUpperCase(int codePoint) * （判斷char的值是不是數字） * 4.1.5）public static boolean isDigit(char ch) * 功能：用於判斷ch:char是否是一個數字 * public static boolean isDigit(int codePoint) * 備註：這個函數也適用於判斷一個字符是否是數字，只不過這個函數功能更強大些，因爲這個函數使用字符在Unicode表中的位置訪問Unicode表中的字符 * codePoint：int是32位的，可以訪問到Unicode表中的所有字符 * 但是第一個函數使用16位的ch：char是訪問不到Unicode表中的所有字符的，只能訪問到上半部分字符 * （大寫變小寫，小寫變大寫） * 4.1.6）public static char toLowerCase(char ch) * public static int toLowerCase(int codePoint) * 4.2）實例成員函數 * （Character對象所代表的char型數值--->char型數值） * 4.2.1） public char charValue() * （Character對象所代表的char型數值--->hashCode） * 4.2.2）public int hashCode() * （Character對象所代表的char型數值--->string字符串） * 4.2.3）public String toString() * （比較兩個Character對象的大小） * 4.2.5）public boolean equals(Object obj) * */ package datatype; public class JavaAPI_Character { public static void main(String[] args){ Character ch=new Character('a'); } }
-
-
