String本质上是一个字符数组;
构造方法
String有很多构造方法，这边只介绍几个：
- String(String original)
- String(char[] value);
- String(char[] value, int offset, int count);
来看几个例子：
1: String(String original)
public class TestString {
public static void main(String[] args) {
String s1 = new String("hello");
System.out.println(s1); // String类的对象 直接输出时不会输出内存地址 而是内存地址指向的对象中包含的内容
}
}
String是一种比较特殊的引用类型,直接输出的时候输出的不是内存地址，而是其指向的对象的内容。
2: String(char[] value);
public class TestString {
public static void main(String[] args) {
char[] chs = {'h','e','l','l','o'};
String s2 = new String(chs);
System.out.println(s2); // hello
}
}
3.: String(char[] value, int offset, int count):
public class TestString {
public static void main(String[] args) {
char[] chs = {'h','e','l','l','o'};
String s3 = new String(chs, 1, 3);
System.out.println(s3); // ell 从第1个index开始，截取长度为3的字符串
}
}
4: 字面量方式：
public class TestString {
public static void main(String[] args) {
String s4 = "hello";
System.out.println(s4); // hello
}
}
字面量创建和使用构造方法(即 new String())创建的区别
首先明确一点，字符串的内容是存储在方法区中的常量池里面的，这么做是为了字符串的重复使用。
来看例子:
public class TestString {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false
String s3 = "hello";
String s4 = "hello";
System.out.println(s3 == s4); // true
System.out.println(s1 == s3); // false
}
}
那么使用new String()操作的时候，只要有new操作，那么肯定要在堆中开辟空间，所以s1,s2指向了堆中的不同地址的对象。但是由于字符串的内容是存储在方法区中的常量池里面的，所以s1,s2中的内容，还是一个地址，指向的是常量池中的内容即"hello"，s1和s2的内存地址不同，所以s1 == s2为false。
然而对于字面量方式创建字符串来说，并没有new操作，所以没有在堆中进行开辟空间，而是直接将s3,s4直接指向了常量池中的内容即"hello",所以s3 == s4是true(常量池中，重复使用)。
另外关于s1 == s3为false,是因为s1存的是指向的是堆中的对象的地址，这个堆中的对象的内容才是指向常量池中字符串的地址，而s3存的就是指向常量池中字符串的这个地址。所以二者不是一个地址。
pic
总结一下：
new String()创建的字符串是在堆内存，其的值又指向了方法区的常量池。
而字面量创建的字符串，直接就指向了方法区的常量池。
String类常用的判断功能
- boolean equals(Object obj)
- boolean equalsIgnoreCase(String str)
- boolean startsWith(String str)
- boolean endsWith(String str)
public class TestString {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "Hello";
String s3 = "hello";
System.out.println( s1.equals(s2)); // false
System.out.println( s1.equals(s3)); // true
System.out.println( s1.equalsIgnoreCase(s2)); // true
}
}
public class TestString {
public static void main(String[] args) {
String s1 = "hello";
System.out.println( s1.startWith("hel")); // true
System.out.println( s1.startWith("DeeJay")); // false
}
}
String类常用的获取功能
- int length()
- char charAt(int index)
- int indexOf(String str)
- String subString(int start)
- String subString(int start, int end)
public class TestString {
public static void main(String[] args) {
String s1 = "hello";
System.out.println( s1.length() ); // 5
System.out.println( s1.charAt(0)); // h
System.out.println( s1.indexOf("h")); // 0
System.out.println( s1.subString(2)); // llo
System.out.println( s1.subString(2,4)); // ll
}
}
String类常见的转换功能
- char[] toCharArray()
- String toLowerCase()
- String toUpperCase()
public class TestString {
public static void main(String[] args) {
String s1 = "Hello";
char[] chs = s1.toCharArray();
for(int i = 0; i < chs.length; i ++) {
System.out.println(chs[i]); // 依次输出 H e l l o
}
System.out.println( s1.toLowerCase() ); // hello
System.out.println( s1.toUpperCase() ); // HELLO
}
}
字符串的遍历方法：
1. length()加上charAt()
2. 把字符串转换为字符数组toCharArray()，然后遍历数组。
public class TestString {
public static void main(String[] args) {
String s1 = "hello wrold";
for(int i = 0; i < s1.length(); i ++) {
System.out.println(s1.charAt(i));
}
// 或者也可以使用toCharArray()
char[] chs = s1.toCharArray();
for(int i = 0; i < chs.length; i ++) {
System.out.println(chs[i]);
}
}
}
String类的其他常用api
- String trim()
- String[] split(String str)
public class TestString {
public static void main(String[] args) {
String str = "a,b,c";
String[] strArr = str.split(",");
for(int i = 0; i < strArr.length; i ++) {
System.out.println(strArr[i]); // 依次输出 a b c
}
}
}
关于StringBuilder
对于简单的字符串拼接问题，由于String不可变，每次进行拼接的时候，其实本质上是在先在常量池中新增一个空间存放"world",然后在新增一个空间存放"helloworld",最后把str指向这个"helloworld"，而之前常量池中的"hello"和"world"就变成了垃圾。
public class TestString {
public static void main(String[] args) {
String str = "hello";
str += "world";
System.out.println(str);
}
}
而StringBuilder就可以解决这个问题，StringBuilder是一个可变的字符序列.
String的内容是固定不可变的，而StringBuilder是可变的
关于StringBuilder的使用
public class TestStringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder(); // 默认的无参的构造方法 创建的容量为16
System.out.println(sb.capaticy()); // 16
System.out.println(sb.length()); // 0
}
}
StringBuilder类常见操作
- public StringBuilder append(任意类型)
- public StringBuilder reverse()
public class TestStringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
StringBuilder sb2 = sb.append("Hello") ;
System.out.println(sb); // Hello
System.out.println(sb2); // Hello
System.out.println(sb == sb2); // true
}
}
来看这个例子 ，append返回的也是一个StringBuilder类的值，同时调用append()之后，原来的那个sb的值也发生了改变，最后发现sb 和 sb2 指向的是同一块地址，即说明StringBuilder是可变的(可修改)。
对于append()，其改变了自身之后，又返回了其自身，所以支持链式调用。
public class TestStringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("Hello").append("World").append(true);
System.out.println(sb); // HelloWorldtrue
}
}
reverse()就是反转StringBuilder类的对象。
String和StringBuilder类的相互转换
- StringBuilder ====> String:
使用public String toString()
public class TestStringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("hello").append("world");
String s = sb.toString();
System.out.println(s);
}
}
- String ====> StringBuilder:
使用构造函数StringBuilder(String str)
public class TestStringBuilder {
public static void main(String[] args) {
String s = "Hello world";
StringBuilder sb = new StringBuilder(s);
System.out.println(sb); // Hello world
}
}
