java基础---->java的八种基本数据类型及其包装类
一、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'); } }
-
-
学习的过程中总会得到一些心得体会，认真地将它们记录下来并分享给每一个愿意花费时间去阅读它们的人，然后意外地收获某个读者的评论，从而激发出新的感想，是一件十分令人欢快的事。如果你也在研习这方面的知识，欢迎加入到我们的队伍中来，和我们一起进步吧（^_^）
