JAVA常用类的使用方法

JAVA常用类的使用方法１、Integer类２、Float类３、Double类４、Character类５、String类６、StringTokenizer类７、StringBuffer类８、Random类

1．Integer类的使用方法

Interger：整数类型１、属性。staticintMAX_VALUE：返回最大的整型数；staticintMIN_VALUE：返回最小的整型数；staticClassTYPE：返回当前类型。

例子：System.out.println("Integer.MAX_VALUE:"+Integer.MAX_VALUE);结果为：Integer.MAX_VALUE:2147483647２、构造函数。Integer(intvalue)：通过一个int的类型构造对象；Integer(Strings)：通过一个String的类型构造对象；例子：Integeri=newInteger("1234");生成了一个值为1234的Integer对象。

３、方法。

说明：1.所有方法均为public；

2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。

1.byteValue()：取得用byte类型表示的整数；

2.intcompareTo(IntegeranotherInteger)：比较两个整数。相等时返回０；小于时返回负数；大于时返回正数。

例子：Integeri=newInteger(1234);System.out.println("i.compareTo:"+i.compareTo(newInteger(123)));

结果为：i.compareTo:13.intcompareTo(Objecto)：将该整数与其他类进行比较。如果o也为Integer类，进行方法2的操作；

否则，抛出ClassCastException异常。

4.staticIntegerdecode(Stringnm)：将字符串转换为整数。

5.doubledoubleValue()：取得该整数的双精度表示。

6.booleanequals(Objectobj)：比较两个对象。

7.floatfloatValue()：取得该整数的浮点数表示。

8.staticIntegergetInteger(Stringnm)：根据指定名确定系统特征值。

9.staticIntegergetInteger(Stringnm，intval)：上面的重载。

10.staticIntegergetInteger(Stringnm，Integerval)：上面的重载。

11.inthashCode()：返回该整数类型的哈希表码。

12.intintValue()：返回该整型数所表示的整数。

13.longlongValue()：返回该整型数所表示的长整数。

14.staticintparseInt(Strings)：将字符串转换成整数。s必须是时进制数组成，否则抛出NumberFormatException异常。15.staticintparseInt(Strings，intradix)：以radix为基数radix返回s的十进制数。所谓的基数，就是“几进制”。例子：Strings1=newString("1010");System.out.println("Integer.parseInt(Strings，intradix):"+Integer.parseInt(s1，2));结果为：Integer.parseInt(Strings，intradix):1016.shortshortValue()：返回该整型数所表示的短整数。17.staticStringtoBinaryString(inti)：将整数转为二进制数的字符串。

18.staticStringtoHexString(inti)：将整数转为十六进制数的字符串。

19.staticStringtoOctalString(inti)：将整数转为八进制数的字符串。

20.StringtoString()：将该整数类型转换为字符串。

21.staticStringtoString(inti)：将该整数类型转换为字符串。不同的是，此为类方法。

22.staticStringtoString(inti，intradix)：将整数i以基数radix的形式转换成字符串。例子：inti1=54321;System.out.println("Integer.toString(inti，intradix):"+Integer.toString(i1，16));结果为：Integer.toString(inti，intradix):d43123.staticIntegervalueOf(Strings)：将字符串转换成整数类型。24.staticIntegervalueOf(Strings，intradix)：将字符串以基数radix的要求转换成整数类型。

 

[8]

2．Float类的使用方法

 

Float：实数类型

１、属性。

1.staticfloatMAX_VALUE：返回最大浮点数，在不同硬件平台中由Float.intBitsToFloat(0x7f7fffff)计算得出。2.staticfloatMIN_VALUE：返回最小浮点数，在不同硬件平台中由Float.intBitsToFloat(0x1)计算得出。

3.staticfloatNaN：表示非数值类型的浮点数，在不同硬件平台中由Float.intBitsToFloat(0x7fc00000)计算得出。4.staticfloatNEGATIVE_INFINITY：返回负无穷浮点数，在不同硬件平台中由Float.intBitsToFloat(0xff800000)计算得出。5.staticfloatPOSITIVE_INFINITY：返回正无穷浮点数，在不同硬件平台中由Float.intBitsToFloat(0x7f800000)计算得出。6.staticClassTYPE：返回当前类型。

２、构造函数。Float(doublevalue)：以double类型为参数构造Float对象。

Float(floatvalue)：以Float类型为参数构造Float对象。Float(Strings)：以String类型为参数构造Float对象。

３、方法。说明：

1.所有方法均为public；

2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。

1.bytebyteValue()：返回以字节表示的浮点数。

2.staticintcompare(floatf1，floatf2)：此为类方法，比较f1和f2。相当于newFloat(f1).compareTo(newFloat(f2))。如果f1与f2相等，返回０；小于关系，返回负数；大于关系，返回正数。

3.intcompareTo(FloatanotherFloat)：此为对象方法，当前对象与anotherFloat比较。与2的比较规则相同。

4.intcompareTo(Objecto)：当前对象与o进行比较，如果o属于Float类，那么，相当于3；如果是其他类，则抛出ClassCastException异常。

5.doubledoubleValue()：返回浮点数的双精度值。

6.booleanequals(Objectobj)：比较当前Float对象与obj的内容是否相同。大多数情况是比较两个Float对象的值是否相等，相当于f1.floatValue()==f2.floatValue()的值。与2、3、4不同的是：6返回boolean型。

7.staticintfloatToIntBits(floatvalue)：按照IEEE754转化成float并输出它的十进制数值。

8.floatfloatValue()：返回该浮点数对象的浮点数值。

9.inthashCode()：返回该Float对象的哈希表码。

10.intintValue()：返回该Float对象的整数值（整数部分）。

11.booleanisInfinite()：判断该Float对象是否是无穷。

12.staticbooleanisInfinite(floatv)：与11类似，不同的是：此为类方法，判断的是v。

13.booleanisNaN()：判断该Float对象是否为非数值。

14.staticbooleanisNaN(floatv)：功能与13一样，只不过判断v。

15.longlongValue()：返回该Float对象的长整数值。

16.staticfloatparseFloat(Strings)：将字符串转换成浮点数。

17.shortshortValue()：返回该Float对象的短整数值。

18.StringtoString()：将该Float对象转换成字符串。

19.staticStringtoString(floatf)：功能与18一样，只是转换f。

20.staticFloatvalueOf(Strings)：将字符串转换成浮点数。例子：Floatf=newFloat(1237.45);Floatfs=newFloat("123.45");Floatfd=newFloat(1234146865679824657987947924623724749.16416925);System.out.println("f.compare(fs):"+f.compareTo(fs));System.out.println("f.compareTo(fd):"+f.compareTo(fd));System.out.println("Float.compare(1.23f，3.25f):"+Float.compare(1.23f，3.25f));结果为：f.compare(fs):1f.compareTo(fd):-1Float.compare(1.23f，3.25f):-1Floatf=newFloat(1237.45);System.out.println("f.equals(fs):"+f.equals(fs));结果为：f.equals(fs):false

 

[8]

3．Double类的使用方法

 

Double：双精度类型

１、属性。

1.staticDoubleMAX_VALUE：返回最大双精度数，在不同硬件平台中由Double.longBitsToDouble(0x7fefffffffffffffL)计算得出。2.staticDoubleMIN_VALUE：返回最小双精度数，在不同硬件平台中由Double.longBitsToDouble(0x1L)计算得出。3.staticDoubleNaN：表示非数值类型的双精度数，在不同硬件平台中由Double.longBitsToDouble(0x7ff8000000000000L)计算得出。

4.staticDoubleNEGATIVE_INFINITY：返回负无穷双精度数，在不同硬件平台中由Double.longBitsToDouble(0xfff0000000000000L)计算得出。

5.staticDoublePOSITIVE_INFINITY：返回正无穷双精度数，在不同硬件平台中由Double.longBitsToDouble(0x7ff0000000000000L)计算得出。

6.staticClassTYPE：返回当前类型。

２、构造函数。Double(doublevalue)：以double类型为参数创建Double对象。Double(Strings)：以String类型为参数创建String对象。

３、方法。说明：

1.所有方法均为public；

2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。

1.bytebyteValue()：返回以字节表示的双精度数。

2.staticintcompare(doubled1，doubled2)：此为类方法，比较d1和d2。相当于newDouble(d1).compareTo(newDouble(d2))。如果d1与d2相等，返回０；小于关系，返回负数；大于关系，返回正数。

3.intcompareTo(DoubleanotherDouble)：此为对象方法，当前对象与anotherDouble比较。与2的比较规则相同。

4.intcompareTo(Objecto)：当前对象与o进行比较，如果o属于Double类，那么，相当于3；如果是其他类，则抛出ClassCastException异常。

5.staticlongdoubleToLongBits(doublevalue)：把value按照IEEE754转化成long并输出它的十进制数值。

6.doubledoubleValue()：返回该双精度数对象的双精度数值。

7.booleanequals(Objectobj)：比较当前Double对象与obj的内容是否相同。大多数情况是比较两个Double对象的值是否相等，相当于d1.doubleValue()==d2.doubleValue()的值。

8.floatfloatValue()：返回该浮点数对象的浮点数值。

9.inthashCode()：返回该Double对象的哈希表码。

10.intintValue()：返回该Double对象的整数值（整数部分）。

11.booleanisInfinite()：判断该Double对象是否是无穷。

12.staticbooleanisInfinite(doublev)：与11类似，不同的是：此为类方法，判断的是v。

13.booleanisNaN()：判断该Double对象是否为非数值。

14.staticbooleanisNaN(doublev)：功能与13一样，只不过判断v。

15.longlongValue()：返回该Double对象的长整数值。

16.staticfloatparseFloat(Strings)：将字符串转换成双精度数。

17.shortshortValue()：返回该Double对象的短整数值。

18.StringtoString()：将该Double对象转换成字符串。

19.staticStringtoString(Doublef)：功能与18一样，只是转换f。

20.staticDoublevalueOf(Strings)：将字符串转换成双精度数。

 

[8]

4．Character类的使用方法

 

Character：字符类型

１、属性。staticintMIN_RADIX：返回最小基数。staticintMAX_RADIX：返回最大基数。staticcharMAX_VALUE：字符类型的最大值。staticcharMIN_VALUE：字符类型的最小值。staticClassTYPE：返回当前类型。

２、构造函数。Character(charvalue)：以char参数构造一个Character对象。

３、方法。说明：

1.所有方法均为public；

2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。1.charcharValue()：返回字符对象的值。2.intcompareTo(CharacteranotherCharacter)：当前Character对象与anotherCharacter比较。相等关系返回０；小于关系返回负数；大于关系返回正数。

3.intcompareTo(Objecto)：当前对象与另一个对象进行比较。如果o是Character对象，则与2功能一样；否则，抛出ClassCastException异常。

4.staticintdigit(charch，intradix)：根据基数返回当前字符的值的十进制。如果不满足Character.MIN_RADIX<=radix<=Character.MAX_RADIX，或者，ch不是radix基数中的有效值，返回"-1"；如果ch是“大写”的A到Z之间，则返回ch-‘A‘+10的值；如果是“小写”a到z之间，返回ch-‘a‘+10的值。System.out.println("Character.MIN_RADIX:"+Character.MIN_RADIX);System.out.println("Character.MAX_RADIX:"+Character.MAX_RADIX);System.out.println("Character.digit(‘2‘，2):"+Character.digit(‘2‘，2));System.out.println("Character.digit(‘7‘，10):"+Character.digit(‘7‘，10));System.out.println("Character.digit(‘F‘，16):"+Character.digit(‘F‘，16));结果为：Character.MIN_RADIX:2Character.MAX_RADIX:36Character.digit(‘2‘，2):-1Character.digit(‘7‘，10):7Character.digit(‘F‘，16):155.booleanequals(Objectobj)：与obj对象比较。当且仅当obj不为“null”并且和当前Character对象一致时返回“true”。

6.staticcharforDigit(intdigit，intradix)：根据特定基数判断当前数值表示的字符。4的逆运算，非法数值时返回“‘/u0000‘”。System.out.println("Character.MIN_RADIX:"+Character.MIN_RADIX);System.out.println("Character.MAX_RADIX:"+Character.MAX_RADIX);System.out.println("Character.forDigit(2，2):"+Character.forDigit(2，2));System.out.println("Character.forDigit(7，10):"+Character.forDigit(7，10));System.out.println("Character.forDigit(15，16):"+Character.forDigit(15，16));结果为：Character.MIN_RADIX:2Character.MAX_RADIX:36Character.forDigit(2，2):Character.forDigit(7，10):7Character.forDigit(15，16):f

7.staticintgetNumericValue(charch)：返回字符ch的数值。

8.staticintgetType(charch)：返回字符所属类型。具体有哪些种类请查看Java文档资料。

9.inthashCode()：返回当前字符的哈希表码。

10.staticbooleanisDefined(charch)：判断字符ch在Unicode字符集是否用明确定义。

11.staticbooleanisDigit(charch)：判断字符ch是否为数字。

12.staticbooleanisIdentifierIgnorable(charch)：判断字符ch是否为Unicode字符集中可忽略的字符。13.staticbooleanisISOControl(charch)：判断字符ch是否为ISO标准中的控制字符。

14.staticbooleanisJavaIdentifierPart(charch)：判断字符ch是否为Java中的部分标识符。

15.staticbooleanisJavaIdentifierStart(charch)：判断字符ch是否为Java中的第一个标识符。

16.staticbooleanisLetter(charch)：判断字符ch是否为字母。

17.staticbooleanisLetterOrDigit(charch)：判断字符ch是否为字母或数字。

18.staticbooleanisLowerCase(charch)：判断字符ch是否为小写字母。

19.staticbooleanisMirrored(charc)：根据Unicode表判断字符c是否存在与之方向相反的字符。例如：“［”存在与之方向相反的“］”，结果为：true。20.staticbooleanisSpaceChar(charch)：判断字符ch是否为Unicode中的空格。

21.staticbooleanisUpperCase(charch)：判断字符ch是否为大写字母。

22.staticbooleanisWhitespace(charch)：判断字符ch是否为Java定义中的空字符。其中包括：charc1=‘/u0009‘;//水平列表符charc2=‘/u000A‘;//换行charc3=‘/u000B‘;//垂直列表符charc4=‘/u000C‘;//换页charc5=‘/u000D‘;//回车charc6=‘/u001C‘;//文件分隔符charc7=‘/u001D‘;//组分隔符charc8=‘/u001E‘;//记录分隔符charc9=‘/u001F‘;//单元分隔符

23.staticchartoLowerCase(charch)：转换ch是否为小写。

24.StringtoString()：将当前Character对象转换成字符串。

25.staticStringtoString(charc)：此为类方法，将c转换成字符串。26.staticchartoUpperCase(charch)：转换ch是否为大写。System.out.println("Character.toUpperCase(‘q‘):"+Character.toUpperCase(‘q‘));System.out.println("Character.toLowerCaseCase(‘B‘):"+Character.toLowerCase(‘B‘));结果为：Character.toUpperCase(‘q‘):QCharacter.toLowerCaseCase(‘B‘):b

 

[8]

5．string类的使用方法

 

String：字符串类型此帖参考了maxlyy朋友的帖子，在这里特别感谢。

１、构造函数。String()：构造一个空字符串对象。String(byte[]bytes)：通过byte数组构造字符串对象。String(byte[]bytes，intoffset，intlength)：通过byte数组，从offset开始，总共length长的字节构造字符串对象。String(char[]value)：通过char数组构造字符串对象。String(char[]value，intoffset，intcount)：通过char数组，从offset开始，总共length长的字节构造字符串对象。String(Stringoriginal)：构造一个original的副本。既，拷贝一个original。String(StringBufferbuffer)：通过StringBuffer数组构造字符串对象；byte[]b={‘a‘，‘b‘，‘c‘，‘d‘，‘e‘，‘f‘，‘g‘，‘h‘，‘i‘，‘j‘};char[]c={‘0‘，‘1‘，‘2‘，‘3‘，‘4‘，‘5‘，‘6‘，‘7‘，‘8‘，‘9‘};Stringsb=newString(b);Stringsb_sub=newString(b，3，2);Stringsc=newString(c);Stringsc_sub=newString(c，3，2);Stringsb_copy=newString(sb);System.out.println("sb:"+sb);System.out.println("sb_sub:"+sb_sub);System.out.println("sc:"+sc);System.out.println("sc_sub:"+sc_sub);System.out.println("sb_copy:"+sb_copy);结果为：sb:abcdefghijsb_sub:desc:0123456789sc_sub:34sb_copy:abcdefghij２、方法。说明：1.所有方法均为public；

2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。

1.charcharAt(intindex)：取字符串中的某一个字符，其中的参数index指的是字符串中序数。字符串的序数从0开始到length()-1。Strings=newString("abcdefghijklmnopqrstuvwxyz");System.out.println("s.charAt(5):"+s.charAt(5));结果为：s.charAt(5):f2.intcompareTo(StringanotherString)：当前String对象与anotherString比较。相等关系返回０；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差，另一种情况，较长字符串的前面部分恰巧是较短的字符串，返回它们的长度差。3.intcompareTo(Objecto)：如果o是String对象，和2的功能一样；否则抛出ClassCastException异常。Strings1=newString("abcdefghijklmn");Strings2=newString("abcdefghij");Strings3=newString("abcdefghijalmn");System.out.println("s1.compareTo(s2):"+s1.compareTo(s2));//返回长度差System.out.println("s1.compareTo(s3):"+s1.compareTo(s3));//返回‘k‘-‘a‘的差结果为：s1.compareTo(s2):4s1.compareTo(s3):104.Stringconcat(Stringstr)：将该String对象与str连接在一起。5.booleancontentEquals(StringBuffersb)：将该String对象与StringBuffer对象sb进行比较。6.staticStringcopyValueOf(char[]data)：7.staticStringcopyValueOf(char[]data，intoffset，intcount)：这两个方法将char数组转换成String，与其中一个构造函数类似。8.booleanendsWith(Stringsuffix)：该String对象是否以suffix结尾。Strings1=newString("abcdefghij");Strings2=newString("ghij");System.out.println("s1.endsWith(s2):"+s1.endsWith(s2));结果为：s1.endsWith(s2):true9.booleanequals(ObjectanObject)：当anObject不为空并且与当前String对象一样，返回true；否则，返回false。10.byte[]getBytes()：将该String对象转换成byte数组。11.voidgetChars(intsrcBegin，intsrcEnd，char[]dst，intdstBegin)：该方法将字符串拷贝到字符数组中。其中，srcBegin为拷贝的起始位置、srcEnd为拷贝的结束位置、字符串数值dst为目标字符数组、dstBegin为目标字符数组的拷贝起始位置。char[]s1={‘I‘，‘‘，‘l‘，‘o‘，‘v‘，‘e‘，‘‘，‘h‘，‘e‘，‘r‘，‘!‘};//s1=Iloveher!Strings2=newString("you!");s2.getChars(0，3，s1，7);//s1=Iloveyou!System.out.println(s1);结果为：Iloveyou!12.inthashCode()：返回当前字符的哈希表码。13.intindexOf(intch)：只找第一个匹配字符位置。14.intindexOf(intch，intfromIndex)：从fromIndex开始找第一个匹配字符位置。15.intindexOf(Stringstr)：只找第一个匹配字符串位置。16.intindexOf(Stringstr，intfromIndex)：从fromIndex开始找第一个匹配字符串位置。Strings=newString("writeonce，runanywhere!");Stringss=newString("run");System.out.println("s.indexOf(‘r‘):"+s.indexOf(‘r‘));System.out.println("s.indexOf(‘r‘，2):"+s.indexOf(‘r‘，2));System.out.println("s.indexOf(ss):"+s.indexOf(ss));结果为：s.indexOf(‘r‘):1s.indexOf(‘r‘，2):12s.indexOf(ss):1217.intlastIndexOf(intch)18.intlastIndexOf(intch，intfromIndex)19.intlastIndexOf(Stringstr)20.intlastIndexOf(Stringstr，intfromIndex)以上四个方法与13、14、15、16类似，不同的是：找最后一个匹配的内容。21.intlength()：返回当前字符串长度。22.Stringreplace(charoldChar，charnewChar)：将字符号串中第一个oldChar替换成newChar。23.booleanstartsWith(Stringprefix)：该String对象是否以prefix开始。24.booleanstartsWith(Stringprefix，inttoffset)：该String对象从toffset位置算起，是否以prefix开始。Strings=newString("writeonce，runanywhere!");Stringss=newString("write");Stringsss=newString("once");System.out.println("s.startsWith(ss):"+s.startsWith(ss));System.out.println("s.startsWith(sss，6):"+s.startsWith(sss，6));结果为：s.startsWith(ss):trues.startsWith(sss，6):true25.Stringsubstring(intbeginIndex)：取从beginIndex位置开始到结束的子字符串。26.Stringsubstring(intbeginIndex，intendIndex)：取从beginIndex位置开始到endIndex位置的子字符串。27.char[]toCharArray()：将该String对象转换成char数组。28.StringtoLowerCase()：将字符串转换成小写。29.StringtoUpperCase()：将字符串转换成大写。Strings=newString("java.lang.ClassString");System.out.println("s.toUpperCase():"+s.toUpperCase());System.out.println("s.toLowerCase():"+s.toLowerCase());结果为：s.toUpperCase():JAVA.LANG.CLASSSTRINGs.toLowerCase():java.lang.classstring30.staticStringvalueOf(booleanb)31.staticStringvalueOf(charc)32.staticStringvalueOf(char[]data)33.staticStringvalueOf(char[]data，intoffset，intcount)34.staticStringvalueOf(doubled)35.staticStringvalueOf(floatf)36.staticStringvalueOf(inti)37.staticStringvalueOf(longl)38.staticStringvalueOf(Objectobj)以上方法用于将各种不同类型转换成Java字符型。这些都是类方法。

 

[8]

6．StringTokenizer类的使用方法

 

StringTokenizer：字符串分隔解析类型属于：java.util包。１、构造函数。1.StringTokenizer(Stringstr)：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘/t’)”、“换行符(‘/n’)”、“回车符(‘/r’)”。2.StringTokenizer(Stringstr，Stringdelim)：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符。3.StringTokenizer(Stringstr，Stringdelim，booleanreturnDelims)：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。２、方法。说明：1.所有方法均为public；2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。1.intcountTokens()：返回nextToken方法被调用的次数。如果采用构造函数1和2，返回的就是分隔符数量(例2)。2.booleanhasMoreTokens()：返回是否还有分隔符。3.booleanhasMoreElements()：结果同2。4.StringnextToken()：返回从当前位置到下一个分隔符的字符串。5.ObjectnextElement()：结果同4。6.StringnextToken(Stringdelim)：与4类似，以指定的分隔符返回结果。例子：Strings=newString("TheJavaplatformistheidealplatformfornetworkcomputing");StringTokenizerst=newStringTokenizer(s);System.out.println("TokenTotal:"+st.countTokens());while(st.hasMoreElements()){System.out.println(st.nextToken());}结果为：TokenTotal:10TheJavaplatformistheidealplatformfornetworkcomputing例2:Strings=newString("The=Java=platform=is=the=ideal=platform=for=network=computing");StringTokenizerst=newStringTokenizer(s，"="，true);System.out.println("TokenTotal:"+st.countTokens());while(st.hasMoreElements()){System.out.println(st.nextToken());}结果为：TokenTotal:19The=Java=platform=is=the=ideal=platform=for=network=computing

[8]

7．StringBuffer类的使用方法

 

StringBuffer：StringBuffer类型描述：在实际应用中，经常回遇到对字符串进行动态修改。这时候，String类的功能受到限制，而StringBuffer类可以完成字符串的动态添加、插入和替换等操作。１、构造函数。StringBuffer()：构造一个没有任何字符的StringBuffer类。StringBuffer(intlength)：：构造一个没有任何字符的StringBuffer类，并且，其长度为length。StringBuffer(Stringstr)：以str为初始值构造一个StringBuffer类。２、方法。说明：1.所有方法均为public；2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。1.StringBufferappend(booleanb)2.StringBufferappend(charc)3.StringBufferappend(char[]str)4.StringBufferappend(char[]str，intoffset，intlen)5.StringBufferappend(doubled)6.StringBufferappend(floatf)7.StringBufferappend(inti)8.StringBufferappend(longl)9.StringBufferappend(Objectobj)10.StringBufferappend(Stringstr)11.StringBufferappend(StringBuffersb)以上的方法都是向字符串缓冲区“追加”元素，但是，这个“元素”参数可以是布尔量、字符、字符数组、双精度数、浮点数、整型数、长整型数对象类型的字符串、字符串和StringBuffer类等。如果添加的字符超出了字符串缓冲区的长度，Java将自动进行扩充。Stringquestion=newString("1+1=");intanswer=3;booleanresult=(1+1==3);StringBuffersb=newStringBuffer();sb.append(question);sb.append(answer);sb.append(‘/t‘);sb.append(result);System.out.println(sb);结果为：1+1=3false12.intcapacity()：返回当前StringBuffer对象（字符串缓冲区）的总空间，而非字符号串的长度。13.charcharAt(intindex)：在当前StringBuffer对象中取索引号为index的字符。第一个字符的索引为“0”14.StringBufferdelete(intstart，intend)：删除当前StringBuffer对象中以索引号start开始，到end结束的子串。15.StringBufferdeleteCharAt(intindex)：删除当前StringBuffer对象中索引号为index的字符。16.voidensureCapacity(intminimumCapacity)：重新设置字符号串缓冲区的总空间。如果minimumCapacity大于当前的总空间，则新的空间被设置：一种结果是minimumCapacity；另一种结果是{“老空间”乘2加2}。StringBuffersb1=newStringBuffer(5);StringBuffersb2=newStringBuffer(5);sb1.ensureCapacity(6);sb2.ensureCapacity(100);System.out.println("sb1.Capacity:"+sb1.capacity());System.out.println("sb2.Capacity:"+sb2.capacity());结果为：sb1.Capacity:12sb2.Capacity:10017.voidgetChars(intsrcBegin，intsrcEnd，char[]dst，intdstBegin)：从当前StringBuffer对象的索引号srcBegin开始，到srcEnd结束的子串，赋值到字符数组dst中，并且从dst的索引号dstBegin开始。StringBuffersb=newStringBuffer("Iloveher!");char[]i={‘I‘，‘‘，‘l‘，‘o‘，‘v‘，‘e‘，‘‘，‘y‘，‘o‘，‘u‘};sb.getChars(7，10，i，7);System.out.println("sb:"+sb);结果为：sb:Iloveher!18.intindexOf(Stringstr)：返回当前StringBuffer对象中，第一个满足str子串的位置。19.intindexOf(Stringstr，intfromIndex)：从当前StringBuffer对象的fromIndex开始查找，返回第一个满足str子串的位置。20.StringBufferinsert(intoffset，booleanb)21.StringBufferinsert(intoffset，charc)22.StringBufferinsert(intoffset，char[]str)23.StringBufferinsert(intindex，char[]str，intoffset，intlen)24.StringBufferinsert(intoffset，doubled)25.StringBufferinsert(intoffset，floatf)26.StringBufferinsert(intoffset，inti)27.StringBufferinsert(intoffset，longl)28.StringBufferinsert(intoffset，Objectobj)29.StringBufferinsert(intoffset，Stringstr)以上的方法都是在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。30.intlastIndexOf(Stringstr)：返回当前StringBuffer对象中，最后一个满足str子串的位置。31.intlastIndexOf(Stringstr，intfromIndex)：从当前StringBuffer对象的fromIndex开始查找，返回最后一个满足str子串的位置。32.intlength()：返回当前StringBuffer对象（字符缓冲区）中，字符串的长度。注意：此方法与capacity()不同。33.StringBufferreplace(intstart，intend，Stringstr)：替换当前StringBuffer对象的字符串。从start开始，到end结束的位置替换成str。34.StringBufferreverse()：将字符串翻转。StringBuffersb=newStringBuffer("0123456789");System.out.println("sb.reverse():"+sb.reverse());结果为：sb.reverse():987654321035.voidsetCharAt(intindex，charch)：设置索引号index的字符为ch。36.voidsetLength(intnewLength)：重新设置字符串缓冲区中字符串的长度，如果newLength小于当前的字符串长度，将截去多余的字符。StringBuffersb=newStringBuffer("0123456789");sb.setLength(5);System.out.println("sb:"+sb);结果为：sb:0123437.Stringsubstring(intstart)：取当前StringBuffer对象中，从start开始到结尾的子串。38.Stringsubstring(intstart，intend)：取当前StringBuffer对象中，从start开始到end的子串。39.StringtoString()：将当前StringBuffer对象转换成String对象。

[8]

8．Random类的使用方法。

 

属于包：java.util.RandomRandom：随机类型１、属性。无。２、构造函数。Random()：创建一个新的随机数发生器。Random(longseed)：用一个种子（长整型）创建一个随机数发生器。３、方法。说明：1.所有方法均为public；2.书写格式：［修饰符］<返回类型<方法名（［参数列表］）如：staticintparseInt(Strings)表示：此方法（parseInt）为类方法（static），返回类型为（int），方法所需参数为String类型。1.protectedintnext(intbits)：产生下一个伪随机数。2.booleannextBoolean()：返回下一个从随机发生器的系列中得到的均匀分布的布尔值。3.voidnextBytes(byte[]bytes)：产生随机字节数组放到指定的数组中。4.doublenextDouble()：返回下一个从随机发生器的系列中得到的均匀分布的0.0到1.0的双精度类型值。5.floatnextFloat()：返回下一个从随机发生器的系列中得到的均匀分布的0.0到1.0的浮点类型值。6.doublenextGaussian()：返回下一个从随机发生器的系列中得到的符合均匀分布的0.0的平均数到1.0方差的高斯分布双精度类型值。7.intnextInt()：返回下一个从随机发生器的系列中得到的均匀分布的整型值。8.intnextInt(intn)：返回下一个从随机发生器的系列中得到的均匀分布的0到指定整型数（n）之间的整型值。9.longnextLong()：返回下一个从随机发生器的系列中得到的均匀分布的长整型值。10.voidsetSeed(longseed)：设置随机数发生器的种子为一个长整型数。关于种子的描述：这个类的对象使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，并且，各自对它们以同样的顺序调用方法，则它们会产生相同的数字序列。下面就对上面的介绍做一个实验，尤其注意相同种子时的结果，如果用默认的构造函数构造对象，他们是属于同一个种子的。importjava.util.Random;publicclassTestRandom{publicstaticvoidmain(String[]args){Randomr1=newRandom(50);System.out.println("第一个种子为50的Random对象");System.out.println("r1.nextBoolean():/t"+r1.nextBoolean());System.out.println("r1.nextInt():/t/t"+r1.nextInt());System.out.println("r1.nextDouble():/t"+r1.nextDouble());System.out.println("r1.nextGaussian():/t"+r1.nextGaussian());System.out.println("---------------------------");Randomr2=newRandom(50);System.out.println("第二个种子为50的Random对象");System.out.println("r2.nextBoolean():/t"+r2.nextBoolean());System.out.println("r2.nextInt():/t/t"+r2.nextInt());System.out.println("r2.nextDouble():/t"+r2.nextDouble());System.out.println("r2.nextGaussian():/t"+r2.nextGaussian());System.out.println("---------------------------");Randomr3=newRandom(100);System.out.println("种子为100的Random对象");System.out.println("r3.nextBoolean():/t"+r3.nextBoolean());System.out.println("r3.nextInt():/t/t"+r3.nextInt());System.out.println("r3.nextDouble():/t"+r3.nextDouble());System.out.println("r3.nextGaussian():/t"+r3.nextGaussian());System.out.println("结果一目了然！");}}结果：第一个种子为50的Random对象r1.nextBoolean():truer1.nextInt():-1727040520r1.nextDouble():0.6141579720626675r1.nextGaussian():2.377650302287946---------------------------第二个种子为50的Random对象r2.nextBoolean():truer2.nextInt():-1727040520r2.nextDouble():0.6141579720626675r2.nextGaussian():2.377650302287946---------------------------种子为100的Random对象r3.nextBoolean():truer3.nextInt():-1139614796r3.nextDouble():0.19497605734770518r3.nextGaussian():0.6762208162903859结果一目了然！