本文内容是字符串梳理和总结，本文内容包括：

String与char

一：概念

1. 字符必须使用单引号，必须是一个字符，默认值是 \u0000
2. 字符串是双引号，可用是任意个字符，默认值是null

二：两者之间的转换

String s1 = "abc";
char ch = s1.charAt(1);  //String2char
System.out.println(ch);

String str = String.valueOf(ch); // char2String
System.out.println(str);

String与char数组

一：两者之间的转换

1. char chs[] = toCharArray()：把字符串转换为字符数组
2. new String(chs)：把字符数组转换为字符串

二：转换示例

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入字符串：");
    String source = scanner.nextLine();
    System.out.println("排序后的字符串是：" + sortString(source));
}

public static String sortString(String source) {
    char[] chars = source.toCharArray(); // 字符串转字符数组
    Arrays.sort(chars);
    return new String(chars);  //字符数组转字符串
}

字符串-String与byte数组

一：概念

1. byte bytes[] = "".getBytes()：把字符串转换为字节数组
2. new String(bytes)：把字节数组转换为字符串
3. 捋一下String，char，byte的关系
   1. String 可转成 char数组
   2. String 可转成 byte数组
   3. char 可转成 byte （byte是char的ASCII表示）
   4. byte 可转成 char（char是byte的字符表示）
   5. 以上转换在开发中按需使用

二：案例

1. 需求：晁盖的帐户密码由大写和小写字母组成，请你编程实现讲晁盖密码的小写字母变成大写字母，大写字母变成小写字母。

   例如: aBcXyz 变成 AbCxYZ

2. 代码：

public static void main(String[] args) {
    String original = "abcXYZ";
    String dest = convertPassword(original);
    System.out.println("原始密码：" + original);
    System.out.println("转换后密码：" + dest);
}

public static String convertPassword(String original) {
    byte bytes[] = original.getBytes();  //字符串转byte数组
    for (int i = 0; i < bytes.length; i++) {
        if(bytes[i]<=90){
            bytes[i]+=32;
        }else if(bytes[i]>=97){
            bytes[i]-=32;
        }
    }
    return new String(bytes); //byte数组转字符串
}

字面量和字符串对象

一：字符串的两种使用方式

1. 字符串字面量：双引号直接定义的字符串
2. 字符串对象：new 出来的字符串

二：两种方式的内存分配

• 字面量：在方法区的字符串常量池中分配内存
• 字符串对象：在堆中分配内存

三：使用字面量创建字符串对象

String str1 = "计算机";
String str2 = "计算机";
System.out.println(str1 == str2);

第一行代码

• 执行到括号中“计算机”的时候，会在字符串常量池中添加“计算机”对象。
• 然后将栈中的str1变量指向该对象。

第二行代码

• 执行到括号中“计算机”的时候，发现字符串常量池已存在“计算机”对象。
• 为避免重复创建对象，将栈中的str2变量指向字符串常量池已存在的对象，字符串常量池存在的原因正是如此。

  

小贴士：

//常量字符串的"+"操作，编译阶段直接会合成为一个字符串。
String str = "计算" + "机"; //等同于 String str = "计算机";
 
//对于final字段，编译期直接进行了常量替换。
final String str1 = "计算";
final String str2 = "机";
String str3 = str1 + str2; //等同于String str3 = "计算机";

//变量连接时，jvm会在编译的时候将其优化为StringBuilder 的拼接，其也生成了新对象
String str4 = "123";  
String str5 = new String("123"); 
String str6 = str4 + str5;// 等同于String str6 = new StringBuilder("123").append("123").toString();

四：使用字符串对象创建字符串

String str1 = new String("计算机");
String str2 = new String("计算机");
System.out.println(str1 == str2);

第一行代码

• 执行到括号中“计算机”的时候，会在字符串常量池中添加“计算机”对象。
• 执行完毕后会在堆中创建“计算机”对象，并将栈中的str1变量指向该对象。

第二行代码

• 执行到括号中“计算机”的时候，发现字符串常量池已存在“计算机”对象，不会向常量池中添加”计算机“。
• 执行完毕后会因为new关键字在堆中创建出一个新的对象，并将栈中的变量str2指向该对象。

五：特点

1. 字面量在内存中可共享使用
2. 字符串对象是私有的，不能与其他字符串共享内容

六：测试一下

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); //此处输出什么？答：

String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s3 == s4); //此处输出什么？答：

字符串的内存结构

一：内存分配

1. 字面量在字符串常量池中分配内存，值若存在则直接使用，若值不存在则创建后使用
2. 字符串对象在堆中分配内存，每创建一次字符串对象，就在堆中分配一次内存

二：测试一下

String s1 = "abc";             //分配内存吗？ 
String s2 = "abc";             //分配内存吗？

String s3 = new String("abc"); //分配内存吗？
String s4 = new String("abc"); //分配内存吗？

字符串-值不变,可共享

一：概念

• 字面量的值不可变，重新给字面量赋值时，在内存中产生了新的字面量
• 字面量的值可共享，不同的字面量赋相同的值时，这些字面量共享内存中的值
• 为什么使用字面量：字符串缓存后复用，节省内存，提高程序运行效率

二：示例

代码：

public static void main(String[] args) {
    String str = "云创";
    str = "云创动力";
}

内存

分析：

• 运行str = "云创"时，在常量池中查找是否有"云创"字面量，如果有，就直接使用，如果没有就分配内存，赋值为"云创"。
• 运行str = "云创动力"时，在常量池中查找是否有"云创动力"字面量，如果有，就直接使用，如果没有就分配内存，赋值为"云创动力"。

三：测试一下

可共享

String s1 = "abc";  //此处为abc分配内存吗？
String s2 = "abc";  //此处为abc分配内存吗？
System.out.println(s1 == s2); 

值不变

public static void main(String[] args) {
    String s1 = "abc";  //此处为abc分配内存吗？
    String s2 = "abc";  //此处为abc分配内存吗？
    s2="def";           //此处为def分配内存吗？
    System.out.println(s1); // s1的值是def吗？
}

字符串与基本类型的转换

1. 基本类型转字符串：
   • 方法1：String.valueOf()
   • 方法2：+
2. 字符串转基本类型
   1. Byte.parseByte(data)
   2. Short.parseShort(data)
   3. Integer.parseInt(data)
   4. Long.parseLong(data)
   5. Float.parseFloat(data)
   6. Double.parseDouble(data)
   7. Boolean.parseBoolean(data)
   8. "".charAt(index)

代码演示

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("请输入第一个年龄：");
    String str1= input.next();
    System.out.println("请输入第二个年龄：");
    String str2= input.next();
    int age1 = Integer.parseInt(str1);  //字符串转基本类型
    int age2 = Integer.parseInt(str2);  //字符串转基本类型
    int sum = calc(age1, age2);
    String str3 = String.valueOf(sum);  //基本类型转字符串
    System.out.println("两个年龄之和是"+str3);
}

public static int calc(int a, int b) {
    return a+b;
}

StringBuffer和StringBuilder

一：为什么使用StringBuffer和StringBuilder

• 使用 + 连接创建字符串效率低，因为字符串具有不变性，每 + 一次就要重新为新的值分配一次内存，占用内存多，效率低。
• 使用StringBuffer和StringBuilder创建字符串效率高
  • 每当通过append或者insert追加内容时，不会为每次追加再单独分配内存，而是向new StringBuffer时分配的内存中继续追加内容，节省内存，效率高。

二：两者有什么区别

• 两者用法相同
• 区别是StringBuffer是线程安全的，StringBuilder是非线程安全的

三：代码示例

public static void main(String[] args) {
    StringBuffer buffer = new StringBuffer(); // 在堆中分配内存
    buffer.append("Hello");  //向堆中内存醉驾 Hello ，没有为这次append单独分配内存
    buffer.append("world");  //向堆中继续追加 World ，没有为这次append单独分配内存
    String res = buffer.toString(); // 调用toString方法转换为Stirng后才能使用
    System.out.println(res);
}