java字符串超详解
目录
1. API
1.1 API 概述
2. String
2.1 String概述
2.2 String 构造方法
2.3 String对象的特点
2.4 字符串的比较
2.5 String中的方法
3. StringBuilder
3.1 StringBuilder 概述
3.2 StringBuilder 的构造方法
3.3 StringBuilder 的添加和反转
3.4 StringBuilder 和 String 相互转换
3.5 StringBuilder 中的方法
1. API
1.1 API 概述
API(Application Programming Interface): 应用程序编程接口。是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。
JavaAPI:指的就是JDK中提供的各种功能的Java类这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现
2. String
2.1 String概述
String类代表字符串。java程序中的所有字符串文字（例如"abc"）都被实现为此类的实例。
Java 程序中所有的双引号字符串，都是String 类的对象
String类在java.lang 包下，所以使用的时候不需要导包
字符串的特点：
- 字符串不可变，它们的值在创建后不能被更改
- 虽然String的值是不可变的，但是它们可以被共享
- 字符串效果上相当于字符数组(char[])，但是底层原理是字节数组( byte[]) (JDK8及以前是字符数组，JDK9及以后是字节数组)
2.2 String 构造方法
| 方法名 | 说明 |
|---|---|
| public String() | 创建一个空白字符串对象，不含有任何内容 |
| public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] bys) | 根据字节数组的内容，来创建字符里对象 |
| String s = “abc" | 直接赋值的方式创建字符用对象，内容就是abc |
例如：
public class Demo05 {
public static void main(String[] args) {
// public String() 创建一个空白字符串对象，不含有任何内容
String s1 = new String();
System.out.println("s1:" + s1); // 无内容
// public String(char[] chs) 根据字符数组的内容，来创建字符串对象
char[] c = { 'a', 'b', 'c' };
String s2 = new String(c);
System.out.println("s2:" + s2);// abc
// public String(byte[] bys) 根据字节数组的内容，来创建字符里对象
byte[] b = { 97, 98, 99 };
String s3 = new String(b);
// 97 98 99对应的底层字符分别为a b c 。
// a b c 三个字符在计算机底层存储的是数据分别为97 98 99的值
System.out.println("s3:" + s3);// abc
// String s = “abc" 直接赋值的方式创建字符用对象，内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);// abc
}
}结果：
2.3 String对象的特点
1.通过new 创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同。
char[] chs ={'a','b','c'}; String s1 = new String(chs); String s2 = new String(chs);上面的代码中，JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过s1和s2参考的字符串内容是相同的
2.以" "方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次JVM 都只会建立一个String 对象，并在字符串池中维护
String s3 = "abc"; String s4 = "abc";在上面的代码中，针对第一行代码，JVM 会建立一个String对象放在字符串池中，并给s3参考，第二行则让s4直接参考字符串池中的String对象，也就是说它们本质上是同一个对象
2.4 字符串的比较
使用==做比较
基本类型:比较的是数据值是否相同引用类型:比较的是地址值是否相同
字符串是对象，它比较内容是否相同，是通过一个方法来实现的，equals()
public boolean equals(0bject anObject): 将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串
例如：
public class Demo07 {
public static void main(String[] args) {
char[] c = { 'a', 'b', 'c' };
String s1 = new String(c);
String s2 = new String(c);
String s3 = "abc";
String s4 = "abc";
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.println("---------");
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}结果：
例2：遍历字符串
public char charAt(int index): 返回指定索处的char值，字符串的索引也是从0开始的
遍历字符串，其次要能够获取到字符串的长度
public int length(): 返回此字符串的长度
数组的长度:数组名.length
字符串的长度:字符串对象.length()
import java.util.Scanner;
public class Demo10 {
public static void main(String[] args) {
System.out.println("输入字符串");
Scanner sc = new Scanner(System.in);
String line = sc.next();
// 获取字符串的每一个字符
for (int i = 0; i < line.length(); i++) {
System.out.print(line.charAt(i) + " ");
}
}
}
结果：
例3：统计字符次数
import java.util.Scanner;
public class Demo06 {
public static void main(String[] args) {
System.out.println("输入字符串");
Scanner sc = new Scanner(System.in);
String line = sc.next();
int a = 0;
int b = 0;
int c = 0;
for (int i = 0; i < line.length(); i++) {
if (line.charAt(i) >= '0' && line.charAt(i) <= '9') {
a++;
} else if (line.charAt(i) >= 'a' && line.charAt(i) <= 'z') {
b++;
} else if (line.charAt(i) >= 'A' && line.charAt(i) <= 'Z') {
c++;
}
}
System.out.println("数字有" + a + "位");
System.out.println("小写字母有" + b + "位");
System.out.println("大写字母有" + c + "位");
}
}结果：
例4：拼接字符串
public class Demo08 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
ToString(arr);
}
public static void ToString(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ",");
}
}
System.out.println("]");
}
}结果：
例5：字符串反转
import java.util.Scanner;
public class Demo09 {
public static void main(String[] args) {
System.out.println("输入字符串");
Scanner sc = new Scanner(System.in);
String s = sc.next();
for (int i = s.length() - 1; i >= 0; i--) {
System.out.print(s.charAt(i)+" ");
}
}
}结果：
2.5 String中的方法
| 方法名 | 说明 |
|---|---|
| public boolean equals(Object anObject) | 比较字符串的内容，严格区分大小写(用户名和密码) |
| public char charAt(int index) | 返回指定索引处的 char 值 |
| public int length() | 返回此字符串的长度 |
3. StringBuilder
3.1 StringBuilder 概述
如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费内存空间，而这种操作还不可避免。那么有没有一种比较好的方式可以解决这个问题呢?答察是肯定的，我们可以通过Java 提供的StringBuilder 类就来解决这个问题。
StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器这里的可变指的是StringBuilder对象中的内容是可变的。
String 和 StringBuilder 的区别
- String:内容是不可变的
- StringBuilder:内容是可变的
3.2 StringBuilder 的构造方法
| 方法名 | 说明 |
|---|---|
| public StringBuilder() | 创建一个空白可变字符串对象，不含有任何内容 |
| public StringBuilder(String str) | 根据字符串的内容，来创建可变字符串对象 |
例如：
public class Demo11 {
public static void main(String[] args) {
// public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
StringBuilder s = new StringBuilder();
System.out.println("s:" + s);
System.out.println("s.length()" + s.length());// 长度
// public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
StringBuilder s1 = new StringBuilder("abc");
System.out.println("s1:" + s1);
System.out.println("s1.length()" + s1.length());// 长度
}
}结果：
3.3 StringBuilder 的添加和反转
| 方法名 | 说明 |
|---|---|
| public StringBuilder append(任意类型) | 添加数据，并返回对象本身 |
| public StringBuilder reverse() | 返回相反的字符序列 |
例如：
public class Demo12 {
public static void main(String[] args) {
// public StringBuilder append(任意类型) 添加数据，并返回对象本身
StringBuilder s = new StringBuilder();
StringBuilder ss = new StringBuilder();
// StringBuilder s2 = s.append("abcd");
// System.out.println("s:" + s);
// System.out.println("s2:" + s2);//s2:abcd
// System.out.println("--------");
s.append("abc");
s.append("def");
s.append("ghi");
s.append(123456);
System.out.println(s);
System.out.println("--------");
// 链式编程
ss.append("abc").append("def").append("ghi").append(123456);
System.out.println(ss);
System.out.println("-----------");
// public StringBuilder reverse() 返回相反的字符序列
s.reverse();
ss.reverse();
System.out.println(s);
System.out.println(ss);
}
}结果：
3.4 StringBuilder 和 String 相互转换
1.StringBuilder转换为 String
public String toString():通过toString()就可以实现把StringBuilder转换为String
2.String 转换为 StringBuilder:public StringBuilder(String s): 通过构造方法就可以实现把 String转换为StringBuilder
例如：
public class Demo14 {
public static void main(String[] args) {
// 1.StringBuilder转换为 String
StringBuilder s = new StringBuilder();
s.append("hello");
String st = s.toString();
System.out.println(st);
// 2.String 转换为 StringBuilder:
String st2 = "hello123";
StringBuilder s2 = new StringBuilder(st2);
System.out.println(s2);
}
}结果：
例1：拼接字符串
public class Demo15 {
public static void main(String[] args) {
int[] arr = { 1, 2, 3 };
String s = ToStirng(arr);
System.out.println(s);
}
public static String ToStirng(int[] arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]).append(",");
}
}
sb.append("]");
String s = sb.toString();
return s;
}
}结果：
例2：字符串反转
public class Demo13 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入字符串");
String line = sc.next();
String s = info(line);
System.out.println(s);
}
public static String info(String s) {
// StringBuilder sb=new StringBuilder();
// sb.reverse();
// String ss = sb.toString();
// return ss;
return new StringBuilder(s).reverse().toString();
}
}结果：
3.5 StringBuilder 中的方法
| 方法名 | 说明 |
|---|---|
| public StringBuilder append(任意类型) | 添加数据，并返回对象本身 |
| public StringBuilder reverse() | 返回相反的字符序列 |
| public String toString() | 通过toString()就可以实现把StringBuilder转换为String |