当前位置：文档之家› javaString类的调用方法解读

javaString类的调用方法解读

1 猜数字小游戏

package cn.itcast_03;

import java.util.Scanner;

* 这时猜数字小游戏的代码

public class GuessNumberGame {

private GuessNumberGame() {

}

public static void start() {

// 产生一个随机数

int number = (int) (Math.random() * 100) + 1;

while (true) {

// 键盘录入数据

Scanner sc = new Scanner(System.in);

System.out.println("请输入你要猜的数据(1-100)：");

int guessNumber = sc.nextInt();

// 判断

if (guessNumber > number) {

System.out.println("你猜的数据" + guessNumber + "大了");

} else if (guessNumber < number) {

System.out.println("你猜的数据" + guessNumber + "小了");

} else {

System.out.println("恭喜你，猜中了");

break;

}

2 String类判断功能

package cn.itcast_03;

* String类的判断功能：

* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写 * boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

* boolean contains(String str):判断大字符串中是否包含小字符串

* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾

* boolean isEmpty():判断字符串是否为空。

* 注意：

* 字符串内容为空和字符串对象为空。

* String s = "";

* String s = null;

public class StringDemo {

public static void main(String[] args) {

// 创建字符串对象

String s1 = "helloworld";

String s2 = "helloworld";

String s3 = "HelloWorld";

// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写

System.out.println("equals:" + s1.equals(s2));

System.out.println("equals:" + s1.equals(s3));

System.out.println("-----------------------");

// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写

System.out.println("equals:" +

s1.equalsIgnoreCase(s2));

System.out.println("equals:" +

s1.equalsIgnoreCase(s3));

System.out.println("-----------------------");

// boolean contains(String str):判断大字符串中是否包含小字符串

System.out.println("contains:" +

s1.contains("hello"));

System.out.println("contains:" + s1.contains("hw"));

System.out.println("-----------------------");

// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头

System.out.println("startsWith:" +

s1.startsWith("h"));

System.out.println("startsWith:" +

s1.startsWith("hello"));

System.out.println("startsWith:" +

s1.startsWith("world"));

System.out.println("-----------------------");

// 练习：boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩

// boolean isEmpty():判断字符串是否为空。

System.out.println("isEmpty:" + s1.isEmpty());

String s4 = "";

String s5 = null;

System.out.println("isEmpty:" + s4.isEmpty());

// NullPointerException

// s5对象都不存在，所以不能调用方法，空指针异常

System.out.println("isEmpty:" + s5.isEmpty());

}

3 模拟登录

package cn.itcast_03;

import java.util.Scanner;

* 模拟登录,给三次机会,并提示还有几次。

* 分析：

* A:定义用户名和密码。已存在的。

* B:键盘录入用户名和密码。

* C:比较用户名和密码。

* 如果都相同，则登录成功

* 如果有一个不同，则登录失败

* D:给三次机会，用循环改进，最好用for循环。

public class StringTest {

public static void main(String[] args) {

// 定义用户名和密码。已存在的。

String username = "admin";

String password = "admin";

// 给三次机会，用循环改进，最好用for循环。

for (int x = 0; x < 3; x++) {

// x=0,1,2

// 键盘录入用户名和密码。

Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名：");

String name = sc.nextLine();

System.out.println("请输入密码：");

String pwd = sc.nextLine();

// 比较用户名和密码。

if (name.equals(username) &&

pwd.equals(password)) {

// 如果都相同，则登录成功

System.out.println("登录成功");

break;

} else {

// 如果有一个不同，则登录失败

// 2,1,0

// 如果是第0次，应该换一种提示

if ((2 - x) == 0) {

System.out.println("帐号被锁定，请与班长联系");

} else {

System.out.println("登录失败，你还有" + (2 - x) + "次机会");

}

4 模拟登录三次机会

package cn.itcast_03;

import java.util.Scanner;

* 模拟登录,给三次机会,并提示还有几次。如果登录成功，就可以玩猜数字小游戏了。

* 分析：

* A:定义用户名和密码。已存在的。

* B:键盘录入用户名和密码。

* C:比较用户名和密码。

* 如果都相同，则登录成功

* 如果有一个不同，则登录失败

* D:给三次机会，用循环改进，最好用for循环。

public class StringTest2 {

public static void main(String[] args) {

// 定义用户名和密码。已存在的。

String username = "admin";

String password = "admin";

// 给三次机会，用循环改进，最好用for循环。

for (int x = 0; x < 3; x++) {

// x=0,1,2

// 键盘录入用户名和密码。

Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名：");

String name = sc.nextLine();

System.out.println("请输入密码：");

String pwd = sc.nextLine();

// 比较用户名和密码。

if (name.equals(username) &&

pwd.equals(password)) {

// 如果都相同，则登录成功

System.out.println("登录成功,开始玩游戏");

//猜数字游戏

GuessNumberGame.start();

break;

} else {

// 如果有一个不同，则登录失败

// 2,1,0

// 如果是第0次，应该换一种提示

if ((2 - x) == 0) {

System.out.println("帐号被锁定，请与

班长联系");

} else {

System.out.println("登录失败，你还有" + (2 - x) + "次机会");

}

5 String类获取功能

package cn.itcast_04;

* String类的获取功能

* int length():获取字符串的长度。

* char charAt(int index):获取指定索引位置的字符

* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。 * 为什么这里是int类型，而不是char类型?

* 原因是：'a'和97其实都可以代表'a'

* int indexOf(String str):返回指定字符串在此字符串中第一次出现处

的索引。

* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

* String substring(int start):从指定位置开始截取字符串,默认到末尾。 * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。

public class StringDemo {

public static void main(String[] args) {

// 定义一个字符串对象

String s = "helloworld";

// int length():获取字符串的长度。

System.out.println("s.length:" + s.length());

System.out.println("----------------------");

// char charAt(int index):获取指定索引位置的字符

System.out.println("charAt:" + s.charAt(7));

System.out.println("----------------------");

// int indexOf(int ch):返回指定字符在此字符串中第一次

出现处的索引。

System.out.println("indexOf:" + s.indexOf('l'));

System.out.println("----------------------");

// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。

System.out.println("indexOf:" + s.indexOf("owo"));

System.out.println("----------------------");

// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。

System.out.println("indexOf:" + s.indexOf('l', 4));

System.out.println("indexOf:" + s.indexOf('k', 4)); // -1

System.out.println("indexOf:" + s.indexOf('l', 40)); // -1

System.out.println("----------------------");

// 自己练习：int indexOf(String str,int

// fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。

// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引

System.out.println("substring:" + s.substring(5));

System.out.println("substring:" + s.substring(0));

System.out.println("----------------------");

// String substring(int start,int

// end):从指定位置开始到指定位置结束截取字符串。包括

start索引但是不包end索引

System.out.println("substring:" + s.substring(3, 8));

System.out.println("substring:" + s.substring(0,

s.length()));

}

6 遍历字符串

package cn.itcast_04;

* 需求：遍历获取字符串中的每一个字符

* 分析：

* A:如何能够拿到每一个字符呢?

* char charAt(int index)

* B:我怎么知道字符到底有多少个呢?

* int length()

public class StringTest {

public static void main(String[] args) {

// 定义字符串

String s = "helloworld";

// 原始版本

// System.out.println(s.charAt(0));

// System.out.println(s.charAt(1));

// System.out.println(s.charAt(2));

// System.out.println(s.charAt(3));

// System.out.println(s.charAt(4));

// System.out.println(s.charAt(5));

// System.out.println(s.charAt(6));

// System.out.println(s.charAt(7));

// System.out.println(s.charAt(8));

// System.out.println(s.charAt(9));

// 只需要我们从0取到9

// for (int x = 0; x < 10; x++) {

// System.out.println(s.charAt(x));

// }

// 如果长度特别长，我不可能去数，所以我们要用长度功能

for (int x = 0; x < s.length(); x++) {

// char ch = s.charAt(x);

// System.out.println(ch);

// 仅仅是输出，我就直接输出了

System.out.println(s.charAt(x));

}

7 统计大小写字母

package cn.itcast_04;

* 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

* 举例：

* "Hello123World"

* 结果：

* 大写字符：2个

* 小写字符：8个

* 数字字符：3个

* 分析：

* 前提：字符串要存在

* A:定义三个统计变量

* bigCount=0

* smallCount=0

* numberCount=0

* B:遍历字符串，得到每一个字符。

* length()和charAt()结合

* C:判断该字符到底是属于那种类型的

* 大：bigCount++

* 小：smallCount++

* 数字：numberCount++

* 这道题目的难点就是如何判断某个字符是大的，还是小的，还是数字的。

* ASCII码表：

* 0 48

* A 65

* a 97

* 虽然，我们按照数字的这种比较是可以的，但是想多了，有比这还简单的

* char ch = s.charAt(x);

* if(ch>='0' && ch<='9') numberCount++

* if(ch>='a' && ch<='z') smallCount++

* if(ch>='A' && ch<='Z') bigCount++

* D:输出结果。

* 练习：把给定字符串的方式，改进为键盘录入字符串的方式。

public class StringTest2 {

public static void main(String[] args) {

//定义一个字符串

String s = "Hello123World";

//定义三个统计变量

int bigCount = 0;

int smallCount = 0;

int numberCount = 0;

//遍历字符串，得到每一个字符。

for(int x=0; x

char ch = s.charAt(x);

//判断该字符到底是属于那种类型的

if(ch>='a' && ch<='z'){

smallCount++;

}else if(ch>='A' && ch<='Z'){

bigCount++;

}else if(ch>='0' && ch<='9'){

numberCount++;

}

//输出结果。

System.out.println("大写字母"+bigCount+"个");

System.out.println("小写字母"+smallCount+"个");

System.out.println("数字"+numberCount+"个");

}

8 String转换功能

package cn.itcast_05;

* String的转换功能：

* byte[] getBytes():把字符串转换为字节数组。

* char[] toCharArray():把字符串转换为字符数组。

* static String valueOf(char[] chs):把字符数组转成字符串。

* static String valueOf(int i):把int类型的数据转成字符串。

* 注意：String类的valueOf方法可以把任意类型的数据转成字符串。

* String toLowerCase():把字符串转成小写。

* String toUpperCase():把字符串转成大写。

* String concat(String str):把字符串拼接。

public class StringDemo {

public static void main(String[] args) {

// 定义一个字符串对象

String s = "JavaSE";

// byte[] getBytes():把字符串转换为字节数组。

byte[] bys = s.getBytes();

for (int x = 0; x < bys.length; x++) {

System.out.println(bys[x]);

}

System.out.println("----------------");

// char[] toCharArray():把字符串转换为字符数组。

char[] chs = s.toCharArray();

for (int x = 0; x < chs.length; x++) {

System.out.println(chs[x]);

}

System.out.println("----------------");

// static String valueOf(char[] chs):把字符数组转成字符串。

String ss = String.valueOf(chs);

System.out.println(ss);

System.out.println("----------------");

// static String valueOf(int i):把int类型的数据转成字符串。

int i = 100;

String sss = String.valueOf(i);

System.out.println(sss);

System.out.println("----------------");

// String toLowerCase():把字符串转成小写。

System.out.println("toLowerCase:" + s.toLowerCase());

System.out.println("s:" + s);

// System.out.println("----------------");

// String toUpperCase():把字符串转成大写。

System.out.println("toUpperCase:" + s.toUpperCase());

System.out.println("----------------");

// String concat(String str):把字符串拼接。

String s1 = "hello";

String s2 = "world";

String s3 = s1 + s2;

String s4 = s1.concat(s2);

System.out.println("s3:"+s3);

System.out.println("s4:"+s4);

}

9 转换大写字母

package cn.itcast_05;

* 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

* 举例：

* helloWORLD

* 结果：

* Helloworld

* 分析：

* A:先获取第一个字符

* B:获取除了第一个字符以外的字符

* C:把A转成大写

* D:把B转成小写

* E:C拼接D

public class StringTest {

public static void main(String[] args) {

// 定义一个字符串

String s = "helloWORLD";

// 先获取第一个字符

String s1 = s.substring(0, 1);

// 获取除了第一个字符以外的字符

String s2 = s.substring(1);

// 把A转成大写

String s3 = s1.toUpperCase();

// 把B转成小写

String s4 = s2.toLowerCase();

// C拼接D

String s5 = s3.concat(s4);

System.out.println(s5);

// 优化后的代码

// 链式编程

String result = s.substring(0, 1).toUpperCase()

.concat(s.substring(1).toLowerCase());

System.out.println(result);

}

10 String替换功能

package cn.itcast_06;

* String类的其他功能：

* 替换功能：

* String replace(char old,char new)

* String replace(String old,String new)

* 去除字符串两空格

* String trim()

* 按字典顺序比较两个字符串

* int compareTo(String str)

* int compareToIgnoreCase(String str)

public class StringDemo {

public static void main(String[] args) {

// 替换功能

String s1 = "helloworld";

String s2 = s1.replace('l', 'k');

String s3 = s1.replace("owo", "ak47");

System.out.println("s1:" + s1);

System.out.println("s2:" + s2);

System.out.println("s3:" + s3);

System.out.println("---------------");

// 去除字符串两空格

String s4 = " hello world ";

String s5 = s4.trim();

System.out.println("s4:" + s4 + "---");

System.out.println("s5:" + s5 + "---");

// 按字典顺序比较两个字符串

String s6 = "hello";

String s7 = "hello";

String s8 = "abc";

String s9 = "xyz";

System.out.println(https://www.doczj.com/doc/743604589.html,pareTo(s7));// 0

System.out.println(https://www.doczj.com/doc/743604589.html,pareTo(s8));// 7

System.out.println(https://www.doczj.com/doc/743604589.html,pareTo(s9));// -16 }

}

StringTest.java

package cn.itcast_06;

* 如果我们看到问题了，看怎么办呢?

* 看源码。

public class StringTest {

public static void main(String[] args) {

String s1 = "hello";

String s2 = "hel";

System.out.println(https://www.doczj.com/doc/743604589.html,pareTo(s2)); // 2

}

11 自动转换字符数组

private final char value[];

字符串会自动转换为一个字符数组。

public int compareTo(String anotherString) {

//this -- s1 -- "hello"

//anotherString -- s2 -- "hel"

int len1 = value.length; //this.value.length--

s1.toCharArray().length--5

int len2 =

anotherString.value.length;//s2.value.length --

s2.toCharArray().length--3

int lim = Math.min(len1, len2); //Math.min(5,3); -- lim=3;

char v1[] = value; //s1.toCharArray()

char v2[] = anotherString.value;

//char v1[] = {'h','e','l','l','o'};

//char v2[] = {'h','e','l'};

int k = 0;

while (k < lim) {

char c1 = v1[k]; //c1='h','e','l'

char c2 = v2[k]; //c2='h','e','l'

if (c1 != c2) {

return c1 - c2;

}

k++;

}

return len1 - len2; //5-3=2;

}

String s1 = "hello";

String s2 = "hel";

System.out.println(https://www.doczj.com/doc/743604589.html,pareTo(s2)); // 2

12 拼接一个字符串

package cn.itcast_07;

* 需求：把数组中的数据按照指定个格式拼接成一个字符串 * 举例：

* int[] arr = {1,2,3};

* 输出结果：

* "[1, 2, 3]"

* 分析：

* A:定义一个字符串对象，只不过内容为空

* B:先把字符串拼接一个"["

* C:遍历int数组，得到每一个元素

* D:先判断该元素是否为最后一个

* 是：就直接拼接元素和"]"

* 不是：就拼接元素和逗号以及空格

* E:输出拼接后的字符串

public class StringTest {

public static void main(String[] args) {

// 前提是数组已经存在

int[] arr = { 1, 2, 3 };

// 定义一个字符串对象，只不过内容为空

String s = "";

// 先把字符串拼接一个"["

s += "[";

// 遍历int数组，得到每一个元素

for (int x = 0; x < arr.length; x++) {

// 先判断该元素是否为最后一个

if (x == arr.length - 1) {

// 就直接拼接元素和"]"

s += arr[x];

s += "]";

} else {

// 就拼接元素和逗号以及空格

s += arr[x];

s += ", ";

}

// 输出拼接后的字符串

System.out.println("最终的字符串是：" + s);

}

13 制定格式拼接成一个字符串

package cn.itcast_07;

* 需求：把数组中的数据按照指定个格式拼接成一个字符串

* 举例：

* int[] arr = {1,2,3};

* 输出结果：

* "[1, 2, 3]"

* 分析：

* A:定义一个字符串对象，只不过内容为空

* B:先把字符串拼接一个"["

* C:遍历int数组，得到每一个元素

* D:先判断该元素是否为最后一个

* 是：就直接拼接元素和"]"

* 不是：就拼接元素和逗号以及空格

* E:输出拼接后的字符串

* 把代码用功能实现。

public class StringTest2 {

public static void main(String[] args) {

// 前提是数组已经存在

int[] arr = { 1, 2, 3 };

// 写一个功能，实现结果

String result = arrayToString(arr);

System.out.println("最终结果是：" + result);

}

* 两个明确：返回值类型：String 参数列表：int[] arr

public static String arrayToString(int[] arr) {

// 定义一个字符串

String s = "";

// 先把字符串拼接一个"["

s += "[";

// 遍历int数组，得到每一个元素

for (int x = 0; x < arr.length; x++) {

// 先判断该元素是否为最后一个

if (x == arr.length - 1) {

// 就直接拼接元素和"]"

s += arr[x];

s += "]";

} else {

// 就拼接元素和逗号以及空格

s += arr[x];

s += ", ";

}

return s;

}

14 字符串反转

package cn.itcast_07;

import java.util.Scanner;

* 字符串反转

* 举例：键盘录入”abc”

* 输出结果：”cba”

* 分析：

* A:键盘录入一个字符串

* B:定义一个新字符串

* C:倒着遍历字符串，得到每一个字符

* a:length()和charAt()结合

* b:把字符串转成字符数组

* D:用新字符串把每一个字符拼接起来

* E:输出新串

public class StringTest3 {

public static void main(String[] args) {

// 键盘录入一个字符串

Scanner sc = new Scanner(System.in);

System.out.println("请输入一个字符串：");

String line = sc.nextLine();

// 定义一个新字符串

String result = "";

// 把字符串转成字符数组

char[] chs = line.toCharArray();

// 倒着遍历字符串，得到每一个字符

for (int x = chs.length - 1; x >= 0; x--) {

// 用新字符串把每一个字符拼接起来

result += chs[x];

}

// 输出新串

System.out.println("反转后的结果是：" + result);

// 改进为功能实现

String s = myReverse(line);

System.out.println("实现功能后的结果是：" + s);

}

* 两个明确：返回值类型：String 参数列表：String

public static String myReverse(String s) {

// 定义一个新字符串

String result = "";

// 把字符串转成字符数组

char[] chs = s.toCharArray();

// 倒着遍历字符串，得到每一个字符

for (int x = chs.length - 1; x >= 0; x--) {

// 用新字符串把每一个字符拼接起来

result += chs[x];

}

return result;

}

15 统计大小写出现的次数

package cn.itcast_07;

* 统计大串中小串出现的次数

* 举例：

* 在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwo aijavagun"

* 结果：

* java出现了5次

* 分析：

* 前提：是已经知道了大串和小串。

* A:定义一个统计变量，初始化值是0

* B:先在大串中查找一次小串第一次出现的位置

* a:索引是-1，说明不存在了，就返回统计变量

* b:索引不是-1，说明存在，统计变量++

* C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串

* D:回到B

public class StringTest4 {

public static void main(String[] args) {

// 定义大串

String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwo aijavagun";

// 定义小串

javamath类常用方法

例如求平方根的(n)，求a的b次方(a, b)，求绝对值(n)等很多。下面是一些演示。publicclassMathTest { publicstaticvoidmain(String[]args) { intn=16; ？ 3)); ？？ } } publicclassMathDemo{ publicstaticvoidmain(Stringargs[]){ /** *abs求绝对值 */ 的时候会取偶数 */ // // // // // // // // // // /** *round四舍五入，float时返回int值，double时返回long值 */ //10 //11 //11 //11 //-10 //-11 //-11 //-10 } }

函数（方法）描述 IEEEremainder(double,double) 按照IEEE754标准的规定，对两个参数进行余数运算。 abs(inta) 返回int值的绝对值 abs(longa) 返回long值的绝对值 abs(floata) 返回float值的绝对值 abs(doublea) 返回double值的绝对值 acos(doublea) 返回角的反余弦，范围在到pi之间 asin(doublea) 返回角的反正弦，范围在-pi/2到pi/2之间 atan(doublea) 返回角的反正切，范围在-pi/2到pi/2之间 atan2(doublea,doubleb) 将矩形坐标(x,y)转换成极坐标(r,theta) ceil(doublea) 返回最小的（最接近负无穷大）double值，该值大于或等于参数，并且等于某个整数cos(double) 返回角的三角余弦 exp(doublea) 返回欧拉数e的double次幂的值 floor(doublea) 返回最大的（最接近正无穷大）double值，该值小于或等于参数，并且等于某个整数log(doublea) 返回（底数是e）double值的自然对数 max(inta,intb) 返回两个int值中较大的一个 max(longa,longb) 返回两个long值中较大的一个 max(floata,floatb) 返回两个float值中较大的一个 max(doublea,doubleb) 返回两个double值中较大的一个 min(inta,intb) 返回两个int值中较小的一个 min(longa,longb) 返回两个long值中较小的一个 min(floata,floatb)

JAVA中常用类的常用方法

JAVA中常用类的常用方法一、类 1、clone()方法创建并返回此对象的一个副本。要进行“ 克隆” 的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法功能：比较引用类型数据的等价性。等价标准：引用类型比较引用，基本类型比较值。存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。二、字符串相关类 String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。 indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar)

JAVA中常用类的常用方法

JAVA屮常用类的常用方法一．java?丨ang.Object 类 1、clone()方法创建丼返M此对象的一个副木。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/743604589.html,ng. Cloneable 接口。 2、equals(Objectobj)方法 0 功能：比较引用类型数据的等价性。 0 等价标准.?引用类型比较引用，基木类型比较值。 0 存在特例.?对File、String、Date及封装类等类型来说，是比较类型及对象的内稃而+ 考虑引用的是否为同一实例。 3、finalize〇方法当垃圾丨"丨收器确定>(、存在对该对象的更多引用时，由对象的垃圾丨"丨收器调用此方法。 4、hashCode〇方法返回该对象的哈希码值。 5、notify〇方法唤醒在此对象监视器上等待的中?个线祝。 6、notifyAII〇方法唤醒在此对象监视器上等待的所有线程= 7、toString()方法返W该对象的字符串表示。在进行String与其它类型数据的连接操作时，&动调用tostringo 方法。可以根据耑要重写toStringO方法。 8、wait()方法在其他线程调用此对象的n〇tify()方法或notifyAIIO方法前，异致当前线程等待。二、字符串相关类 I String 类 charAt(int index)返回指定索引处的char值。compareTo{String anotherString)按字

典顺序比较两个字符串。compareTolgnoreCase(Stringstr)按字典顺序比较两个字符串，不考虑人小写。concat(String str)将指定字符串连接到此字符串的结尾。 endsWith(String suffix)测试此字符串是否以指定的〗?缀结束。equals{Object anObject)将此字符串与指定的对象比较。 equalslgnoreCase(String anotherString)将此String 与另一个String 比较，考虑人小'与’。indexOf(int ch)返H指定字符在此字符串屮第一次出现处的索引。 indexOf(String str)返回第一次出现的指定子字符串在此字符串屮的索引， lastlndexOf(intch)返回指定字符在此字符串中最后??次出现处的索引。 length()返|n丨此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。 split(String regex)根据给定正则表达式的匹配拆分此字符串。startsWith{String prefix)测试此字符串是否以指定的前缀开始。substring(int beginlndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginlndex, int endlndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginlndex 处开始，一直到索引endlndex-1处的字符。 t〇CharArray()将此字符串转换为一个新的字符数组。

JAVA中常用类的常用方法

JAVA中常用类的常用方法一、https://www.doczj.com/doc/743604589.html,ng.Object类 1、clone()方法创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.doczj.com/doc/743604589.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开

JavaMath类常用方法

例如求平方根的Math.sqrt(n)，求a的b次方Math.pow(a, b)，求绝对值Math.abs(n)等很多。下面是一些演示。 public class MathTest { public static void main(String[] args) { int n = 16; System.out.println(Math.sqrt(n)); System.out.println(Math.pow(2, 3)); System.out.println(Math.abs(-4)); System.out.println(Math.log10(100)); } } public class MathDemo { public static void main(String args[]){ /** * abs求绝对值 */ System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /** * ceil天花板的意思，就是返回大的值，注意一些特殊值 */ System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 /** * floor地板的意思，就是返回小的值 */ System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0

java中常用的一些方法

java中常用的一些方法字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符）StringTokenizer(String s,String delim) delim是自己定义的分隔符

nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长 TextField(int x) 构造文本框，x个字符长 TextField(String s) 构造文本框，显示s setText(String s) 设置文本为s getText() 获取文本 setEchoChar(char c) 设置显示字符为c setEditable(boolean) 设置文本框是否可以被修改 addActionListener() 添加监视器 removeActionListener() 移去监视器 2、文本区 TextArea() 构造文本区 TextArea(String s) 构造文本区，显示s TextArea(String s,int x,int y) 构造文本区，x行，y列，显示s TextArea(int x,int y) 构造文本区，x行，y列 TextArea(String s,int x,ing y,int scrollbar) scrollbar的值是： TextArea.SCROLLBARS_BOTH TextArea.SCROLLBARS_VERTICAL_ONLY TextArea.SCROLLBARS_HORIZONTAL_ONLY TextArea.SCROLLBARS_NONE setText(String s) 设置文本为s

java常用类知识点总结

java常用类知识点总结 Java常用类要求: 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作

String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容可以使用insert方法在指定位置上为StringBuffer添加内容字符串的反转操作(较为常见的操作，使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容，查找到返回内容的位置，没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢,答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符

Java标准包中基本常用类和方法

Java标准包中基本常用类和方法 java.util.Vector; java.util.ArrayList; java.util.Date; java.util.Calendar; java.util.Hashtable; java.util.Properties; java.util.Random; java.util.Timer; java.awt.* javax.swing.* Thread String Java常用方法: 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同前缀startsWith(String s) 后缀endsWith(String s) 3、比较两个字符串 equals(String s)

4、把字符串转化为相应的数值 int型Integer.parseInt(字符串) long型Long.parseLong(字符串) float型Folat.valueOf(字符串).floatValue() double型Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号

实验五：Java语言中的常用类

仲恺农业工程学院实验报告纸计算科学与工程（院、系）网络工程专业班组Java语言程序设计课学号姓名实验日期2010/11/19 教师评定实验五：Java语言中的常用类一、实验目的 1、掌握Java语言中的常用类。 2、学习用Java语言中的常用类编写程序。二、实验要求 1、字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串中的小写字母变成大写字母；字符串调用public String toUpperCase()方法返回一个字符串，该字符串把当前字符串的大写字母变成小写字母。String 类的String toUpperCase()方法返回一个字符串，该字符串是把调用该方法的字符串与参数指定的字符串连接。 2、String类的public charAt（int index）方法可以得到当前字符串index 位置上的一个字符。编写程序使用该方法得到一个字符串中的第一个和最后一个字符。 3、输出某年某月的日历页，通过键盘输入年份和月份。二、实验程序和结果 1、 public class Stg{ public static void main(String args[]){

String s2=new String("LI ZHI DONG"); String s3=s1.concat(s2); System.out.println("连接后的字符："+s3); char a[]=s3.toCharArray(); for(int n=0;njava Stg 连接后的字符：wo de ming zi shi LI ZHI DONG 大小写转换后的字符：WO DE MING ZI SHI li zhi dong 或者简单点程序代码： public class Stg{ public static void main(String args[]){

(完整版)Java常用类

常用类 Object类它是Java所有类的根类.所以Java的所有对象都拥有Object类的成员. 1．一般方法 boolean equals(Object obj) //本对象与obj对象相同，返回true String toString() //返回本对象的字符串表达形式，默认返回类名称和十六进制数的编码，即：getClass().getName+’@’+Integer.toHexString(hashCode()); 如果要显示自定义的对象，则需要覆盖这个方法。 protected void finalize() throws Throwable //对象销毁时被自动调用, native int hashCode() 返回对象的Hash码，Hash码是表示对象的唯一值，故Hash码相同的对象是同一对象。 2．控制线程的方法 final native void wait() //等待对象 final native void notify() //通知等待队列中的对象进入就绪队列 final native void notifyAll()//通知所有处于等待队列中的对象进入就绪队列 3．关于Object类的几点说明： 3.1. native <方法> 是指用C++语言编写的方法。 3.2.“==”运算符一般用于基本数据类型的比较，如果用于两个引用对象的比较，则只有当两个引用变量引用同一个对象时，才返回true,否则返回false. String s1=new Strng(“java”); String s2=new Strng(“java”); System.out.pritnln(s1==s2); //显示false 但是，假如不使用new 关键字，创建String 型对象s3,s4,则它们引用的是同一个对象。 String s3=“java”; String s4=“java”;因为没有使用new 关键字，所以s4 引用既存的对象 System.out.pritnln(s3==s4); //显示true, 3.3. 比较对象内容时,使用equals()函数 Object 类的equals()定义 Public boolean equals(Object obj){ return (this==obj); } 由于String 类覆盖了继承自Object类的equals()方法,它比较的是引用对象的内容. 所以,没有覆盖equals()方法的类的对象使用该方法与另一对象进行比较时,永远返回false; 只是因为此时进行比较调用的是Object的equals方法. 4. Object引用型变量 Object引用型变量可以用来引用所有的对对象. Object[] obs=new Object[3]; obs[0]=new Strng(“12345”);//将String对象赋给obs[0] obs[0]=new Boolean(true); obs[0]=new Integer(100); 5. toString()方法

java常用类及用法

字符串操作：字符串的比较： boolean equals()比较此字符串与指定的对象。 Int compareTo() 比较源与（）的大小，两串大小相等返回0 加IgnoreCase()不考虑大小写boolean contains(CharSequence s) 当且仅当此字符串包含 char 值的指定序列时，才返回 true。字符串的长度与组合： char charAt(int index)返回指定索引处的 char 值。 String concat(String str)将指定字符串联到此字符串的结尾。 int length() 返回此字符串的长度。获取子串： String substring(int beginIndex) 返回一个从beginIndex到末尾的子串 String substring(int beginIndex, int endIndex) 返回一个从beginIndex到endIndex-1的字串字符串的转换、替换和分隔： char[] toCharArray() 将此字符串转换为一个新的字符数组。 String toString() 返回此对象本身（它已经是一个字符串！）。 String toLowerCase() 变为全小写 String toUpperCase() 变为全大写 String trim() 返回字符串的副本，忽略前导空白和尾部空白。 String replace(char oldChar, char newChar) 用 newChar 替换此字符串中出现的所有 oldChar，返回新字符 String replaceAll(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的每个子字符串。 String replaceFirst(String regex, String replacement) 使用给定的 replacement 字符串替换此字符串匹配给定的正则表达式的第一个子字符串。 String[] split(String regex) 在给定字符处拆分原字符串为若干字串。找出相应字符或字串（找不到返回-1） int indexOf() 返回（？）填入的字符（串）在源中的第一个索引；（？,num）从num索引开始查找 int lastIndexOf()返回最后一次出现的指定值索引。将字符和数值转化为字符串： Static String valueOf() 将（）填入的参数（任意、包括Obj）转化为字符串 StringBuilder类：构建： StringBuilder() 构建一个容量为16的空字符串生成器，（）填入数字构造指定大小，填入String 构造含有指定字符。 int capacity() 返回当前容量。 char charAt(int index) 指定索引处的 char 值。添改： StringBuilder append() 将特定内容由（）传入buffer StringBuilder insert(int offset,？) 将？变量插在此序列的offset 前 void setCharAt(int index, char ch) 改变索引处的字符为ch。 StringBuilder replace(int start, int end, String str) 替换从start至end-1处字符为str StringBuilder reverse() 反转字符序列。删除： StringBuilder delete(int start, int end) 移除从start索引到end-1索引的字符串。 StringBuilder deleteCharAt(int index) 移除此序列指定位置上的 char。查找： int indexOf(String str) 同String用法 int lastIndexOf()同String用法 int length() 返回长度（字符数）。返回值： int capacity() 返回当前容量。

java中常用类基础入门

1 API的概述 (1)应用程序编程接口。 (2)就是JDK提供给我们的一些提高编程效率的java类。 2 Object类 (1)Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。 (2)Object类的构造方法有一个，并且是无参构造这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造 (3)要掌握的方法： A:toString() 返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。这个表示其实是没有意义的，一般子类都会重写该方法。如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。但是最终还是自动生成。 B:equals() 比较两个对象是否相同。默认情况下，比较的是地址值是否相同。而比较地址值是没有意义的，所以，一般子类也会重写该方法。重写过程，我也详细的讲解和分析了。但是最终还是自动生成。 (4)要了解的方法： A:hashCode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。 B:getClass() 返回对象的字节码文件对象，反射中我们会详细讲解

C:finalize() 用于垃圾回收，在不确定的时间 D:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。 (5)两个注意问题； A:直接输出一个对象名称，其实默认调用了该对象的toString()方法。 B:面试题 ==和equals()的区别? A:== 基本类型：比较的是值是否相同引用类型：比较的是地址值是否相同 B:equals() 只能比较引用类型。默认情况下，比较的是地址值是否相同。但是，我们可以根据自己的需要重写该方法。 3 API概述常用类 ?Object类/Scanner类 ?String类/StringBuffer类/StringBuilder类 ?数组高级和Arrays类 ?基本类型包装类(Integer,Character) ?正则表达式(Pattern,Matcher) ?Math类/Random类/System类 ?BigInteger类/BigDecimal类 Date类/DateFormat类/Calendar类

Java常用方法大全

Java常用方法大全.txt3努力奋斗，天空依旧美丽，梦想仍然纯真，放飞自我，勇敢地飞翔于梦想的天空，相信自己一定做得更好。4苦忆旧伤泪自落，欣望梦愿笑开颜。5懦弱的人害怕孤独，理智的人懂得享受孤独Java常用方法大全字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同前缀 startsWith(String s) 后缀 endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型 Integer.parseInt(字符串) long型 Long.parseLong(字符串) float型 Folat.valueOf(字符串).floatValue() double型 Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号文本框和文本区 1、文本框 TextField() 构造文本框，一个字符长 TextField(int x) 构造文本框，x个字符长 TextField(String s) 构造文本框，显示s setText(String s) 设置文本为s getText() 获取文本

java面向对象编程类的封装接口和基本类库练习题

面向对象编程基本知识练习一、判断题 1.不需要定义类，就能创建对象。（） 2.构造方法用于给类的private 实例变量赋值。（） 3.对象一经声明就可以立即使用。（） 4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（） 5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（） 6.在类定义中，成员访问权限修饰符不能多次出现。（） 7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（） 8.类的方法通常设为public，而类的实例变量一般也设为public。（） 9.构造方法在创建对象时被调用。（） 10.通过点运算符与类对象的引用相连，可以访问此类的成员。（） 11.声明为protected 的类成员只能被此类中的方法访问。（） 12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（） 13.类的成员变量可以放在类体的任意位置。（） 14.声明为protected 的类成员可以被此类作用域中的任何对象访问。（） 15.没有返回值的方法可以用void 来表示，也可以不加。（）二、选择题 1. 下面对对象概念描述错误的是：( ) A 操作是对象的动态属性 B 任何对象都必须有继承性 C 对象间的通讯靠消息传递 D 对象是属性和方法的封装体 2．编译并运行下面的程序，运行结果为：( ) public class A { public static void main(String[] args) { A a=new A()； a.method(8)； } void method(int i) { System.out.println(“int：“+i)； } void method(long i) { System.out.println(“long：“+i)； } } A 程序可以编译运行，输出结果为int：8 B 程序可以编译运行，输出结果为long：8

java常用类知识点总结

Java常用类要求： 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法：（1）字符串的连接操作 String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append 方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。（2）在任意位置处为StringBuffer添加内容可以使用insert方法在指定位置上为StringBuffer添加内容字符串的反转操作（较为常见的操作，使用reverse方法）（3）替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll （4）字符串截取（使用subString方法从指定范围中截取内容）（5）删除指定范围的字符串（使用delete方法删除指定范围内容）（6）查找指定内容是否存在（indexOf查找指定内容，查找到返回内容的位置，没查到返回-1）问题：（1）String s = "Hello";s = s + " world!";这两行代码执行后，原始的String 对象中的内容到底变了没有？没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是"Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，

JAVA中常用类的常用方法

J A V A中常用类的常用方法 Newly compiled on November 23, 2020

JAVA中常用类的常用方法一、类 1、clone()方法创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现. Cloneable接口。 2、equals(Object obj)方法功能：比较引用类型数据的等价性。等价标准：引用类型比较引用，基本类型比较值。存在特例：对File、String、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。二、字符串相关类 l String类 charAt(int index) 返回指定索引处的 char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，一直到索引 endIndex - 1 处的字符。