简介
只记录了简单使用方法
byte
说明：字节数组构造字符串
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
byte[] bytes = {97, 98, 99}; //定义一个字节数组bytes，存入数据97,98,99
String str = new String(bytes); //new一个String类型的str3，存入字节数组bytes
System.out.println("str3 = " + str); //打印结果：str3 = abc
}
}char
说明：字符数组构造字符串
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：char
* 字符数组构造字符串
*/
char[] chars = {'a','b','v','y'}; //定义一个字符数组chars，存入数据a,b,v,y
String str4 = new String(chars); //new一个String类型的str3，存入字节数组bytes
System.out.println("str4 = " + str4); //打印结果：str4 = abvy
}
}equals
说明：判断str1和str2是否相等
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 判断str1和str4是否相等
*/
String str1 = "Hello";
String str2 = "world";
boolean equals = str1.equals(str2); //定义布尔型equals，判断str1和str2是否相等
System.out.println("equals = " + equals); //打印结果：equals = false
//判断str1和str3是否相等
String str3 = "Hello"; //定义一个String类型为str3，存入数据Hello
boolean equals1 = str1.equals(str3); //定义布尔型equals1，判断str1和str3是否相等
System.out.println("equals1 = " + equals1); //打印结果：equals1 = true
}
}equalsIgnoreCase
说明：判断当前字符串与给定字符串是否相同，不区分大小写
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：equalsIgnoreCase
* 判断当前字符串与给定字符串是否相同，不区分大小写
* str1 = Hello
* str2 = Hello
* str1和str2相同，结果应为 true
*/
String str1 = "Hello";
String str2 = "Hello";
boolean b = str1.equalsIgnoreCase(str2); //定义一个布尔型b，判断str1和str2是
System.out.println("b = " + b); //结果：b = true
}
}toUpperCase
说明：将字符串小写字符转换为大写
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：toUpperCase
* 将字符串小写字符转换为大写
* str1 = Hello
* 把str1中的小写字母转换为大写字母，结果应为str6 = HELLO
*/
String str1 = "Hello";
String str2 = str1.toUpperCase(); //将str1中的小写字母转换为大写
System.out.println("str1 = " + str1); //str1此时为 str1 = Hello
System.out.println("str6 = " + str2); //转换大写完毕后的str6为 str6 = HELLO
}
}startsWith
说明：检测字符串是否以指定的前缀开始
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：startsWith
* 检测字符串是否以指定的前缀开始
* str1 = Hello,Java!!!
* 判断str1中开头是否为Hello
* Hello,Java!!!开头是Hello，所以应返回 true
*/
String str1 = "Hello,Java!!!"; //定义String类型str1，存入字符串Hello,Java!!!
boolean starts = str1.startsWith("Hello"); //判断str7中开头是否为Hello，返回布尔型
System.out.println("starts = " + starts); //结果：starts = true
}
}length
说明：获取字节长度
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：length
* 获取字节长度
* str1 = Hello,Java!!!
* str1一共13个字符，所以应该输出13
*/
String str1 = "Hello,Java!!!";
int length = str1.length(); //定义整型length，检测str7占几个字节长度
System.out.println("length = " + length); //打印结果：length = 13
}
}charAt
说明：返回指定索引处的字符。索引范围为从 0 到 length()- 1
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：charAt
* 返回指定索引处的字符。索引范围为从 0 到 length()- 1
* str1 = Hello,Java!!!
* 指定索引8，所以返回字符 v
*/
String str1 = "Hello,Java!!!";
char c = str1.charAt(8); //定义char型c，在str7上索引8
System.out.println("c = " + c); //打印结果：c = v
}
}indexOf
说明：返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：indexOf
* 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
* str1 = Hello,Java!!!
* 在Hello,Java!!!中寻找o出现的第一个位置
*/
String str1 = "Hello,Java!!!";
int indexOf = str1.indexOf("o"); //定义整型indexOf，在str1中索引o，返回第一次出现处
System.out.println("indexOf = " + indexOf); //打印结果：indexOf = 4
}
}lastIndexOf
说明：返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：lastIndexOf
* 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
* str1 = Hello,Java!!!
* 在Hello,Java!!!中寻找a出现的最后一个位置
*/
String str1 = "Hello,Java!!!";
int lastIndexOf = str1.lastIndexOf("a"); //定义整型lastIndexOf，在str1中索引a，返回最后一次出现处
System.out.println("lastIndexOf = " + lastIndexOf); //打印结果：lastIndexOf = 9
}
}substring
说明：定义一个位置，打印这个位置之后的字符串
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：substring
* 返回字符串的子字符串。
* str1 = Hello,Java!!!
* 1、Hello,Java!!!第7个是a，所以输出a和之后的字符串
* 2、Hello,Java!!!第7个是a，第10个是第一个！
*/
String str1 = "Hello,Java!!!";
//第一种，返回字符串规定位置之后的字符串
String substring = str1.substring(7); //定义String类型substring，返回7及7之后的字符串
System.out.println("substring = " + substring); //打印结果：substring = ava!!!
//第二种，返回字符串规定位置之内的字符串
String substring1 = str1.substring(7, 10); //定义String类型substring1，返回7和10之内的字符串
System.out.println("substring1 = " + substring1); //打印结果：substring1 = ava
}
}getBytes
说明：使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：getBytes
* 使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
* str8中a,b,c,ASCII格式转入一个新的byte数组中
*/
byte[] bytes = {97, 98, 99}; //定义一个字节数组bytes，存入数据97,98,99
String str8 = "abc"; //定义String类型str8，存入字符串abc
byte[] bytes1 = str8.getBytes(); //定义一个byte数组，将str8以ASCII格式存入新的数组bytes1中
for (int i = 0; i < bytes1.length; i++) { //i从0开始输出第一个数据，慢慢叠加，i不会超过bytes1的字节长度
System.out.println("bytes[" + i + "] = " + bytes[i]); //打印结果：bytes[0] = 97 bytes[1] = 98 bytes[2] = 99
}
}
}toCharArray
说明：将字符串转换为字符数组。
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：toCharArray
* 将字符串转换为字符数组。
* 将字符串str1存入chars1字符数组
*/
String str1 = "Hello"; //定义String类型str1，存入字符串Hello
char[] chars1 = str1.toCharArray(); //定义一个char数组，将str1存入新的数组chars1中
for (int i = 0; i < chars1.length; i++) { //i从0开始输出第一个数据，慢慢叠加，i不会超过chars1的字节长度
System.out.println("chars1[" + i + "] = " + chars1[i]); //打印结果：chars1[0] = H chars1[1] = e chars1[2] = l chars1[3] = l chars1[4] = o
}
}
}valueOf
说明：返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等，该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：valueOf
* 返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等
* 该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。
*/
double d = 1999.99; //定义一个double类型d，存入数据1999.99
double d1 = d + 1; //定义一个double类型d1，存入数据d+1
System.out.println("d1 = " + d1); //输出d1的值（1999.99+1）结果：d1 = 2000.99
String s = String.valueOf(d); //定义String类型s，将双浮点型d返回至String类型的s
System.out.println("s = " + s); //打印结果：s = 1999.99
String s1 = s + 1; //定义String类型s1, 此时s=1999.99，再+1是拼接
System.out.println("s1 = " + s1); //打印结果：s1 = 1999.991
}
}replace
说明：替换字符串中出现的所有自定字符，并返回替换后的新字符串。
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：replace
* 替换字符串中出现的所有自定字符，并返回替换后的新字符串。
* Hello,Java!!!把Java替换成Welcome，实现输出Hello,Welcome!!!
*/
String str1 = "Hello,Java!!!"; //定义String类型str1，存入字符串Hello,Java!!!
String replace = str1.replace("Java", "Welcome"); //再str1中寻找所有Java，替换成Welcome
System.out.println("replace = " + replace); //打印结果：replace = Hello,Welcome!!!
}
}split
说明：根据给出的特殊字符拆分字符串
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：split
* 根据给出的特殊字符拆分字符串
* str11中H,e,l,l,o，根据“,”拆分字符串，并存入split字符数组中输出
*/
String str1 = "H,e,l,l,o"; //定义String类型str1，存入字符串H,e,l,l,o
String[] split = str1.split(","); //定义String类型数组split，用给出特殊字符“,”划分字符存入字符数组split
for (int i = 0; i < split.length; i++) {
System.out.println("split[" + i + "] = " + split[i]); //打印数组中的字符 打印结果：split[0] = H split[1] = e split[2] = l split[3] = l split[4] = o
}
}
}trim
说明：用于删除字符串的头尾空白符。
package com.kenvie.demo1;
public class ApiJiHe {
public static void main(String[] args) {
/**
* 关键字：trim
* 用于删除字符串的头尾空白符。
* 结果头尾的空白符都被删除了，但字符串中间的没有被删除
*/
String str1 = " Hello,Jav a!!! "; //定义String类型str1，头尾已经中都添加了空格
System.out.println("str12 = " + str1); //输出str1中的字符串
String trim = str1.trim(); //删除str12字符串的头尾空白符，存入String类型的trin中
System.out.println("trim = " + trim); //打印结果:Hello,Jav a!!!
}
}