一、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" * * 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" * 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类所对应的原始基本数据类型，其值为"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" * 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
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'); } }
-
-
