public class Demo2StringConstructor {
  /*
    String类常见构造方法:
    public String() : 创建一个空白字符串对象，不含有任何内容
    public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
    public String(String original) : 根据传入的字符串内容，来创建字符串对象
    String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
    注意:
    String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址
    而是该对象所记录的真实内容. 答案：面向对象-继承, Object类
  */
  public static void main(String[] args) {
    // public String() : 创建一个空白字符串对象，不含有任何内容
    String s1 = new String();
    System.out.println(s1);
    // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
    char[] chs = {'a','b','c'};
    String s2 = new String(chs);
    System.out.println(s2);
    // public String(String original) : 根据传入的字符串内容，来创建字符串对象
    String s3 = new String("123");
    System.out.println(s3);
  }
}

String s1 = "abc";
String s2 = "abc";
s1 == s2 // true
String s1 = "abc";
String s2 = new String("abc");
s1 == s2 // false
String s1 = "java";
String s2 = "jav";
String s3 = s2 + "a"; // 变量 + 常量
s1 == s3 // false 字符串之间使用+号拼接的时候，系统底层会自创建一个StringBuilder对
象，拼接后再转String
String s1 = "java";
String s2 = "jav" + "a"; //常量 + 常量
s1 == s2 // true 虽然是+拼接，但是是常量在拼接，常量优化机制

public class Demo1Equals {
  public static void main(String[] args) {
    String s1 = "abc";
    String s2 = "ABC";
    String s3 = "abc";
    // equals : 比较字符串内容, 区分大小写
    System.out.println(s1.equals(s2));
    System.out.println(s1.equals(s3));
    // equalsIgnoreCase : 比较字符串内容, 忽略大小写
    System.out.println(s1.equalsIgnoreCase(s2));
  }
}

import java.util.Scanner;
public class Test5 {
  public static void main(String[] args) {
    // 1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入手机号:");
    String telString = sc.nextLine();
    // 2. 截取字符串前三位
    String start = telString.substring(0,3);
    // 3. 截取字符串后四位
    String end = telString.substring(7);
    // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
    System.out.println(start + "****" + end);
  }
}

import java.util.Scanner;
public class Test6 {
  public static void main(String[] args) {
    // 1. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入:");
    String s = sc.nextLine();
    // 2. 替换敏感词
    String result = s.replace("TMD","***");
    // 3. 输出结果
    System.out.println(result);
  }
}

public class Test7 {
  public static void main(String[] args) {
    // 2. 键盘录入一个字符串，用 Scanner 实现
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入学生信息:");
    String stuInfo = sc.nextLine();
    // stuInfo = "张三,23";
    // 3. 根据逗号切割字符串，得到（张三）（23）
    String[] sArr = stuInfo.split(",");
    // System.out.println(sArr[0]);
    // System.out.println(sArr[1]);
    // 4. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
    Student stu = new Student(sArr[0],sArr[1]);
    // 5. 调用对象getXxx方法，取出数据并打印。
    System.out.println(stu.getName() + "..." + stu.getAge());
  }
}

public class StringBuilderDemo01 {
  public static void main(String[] args) {
    //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
    StringBuilder sb = new StringBuilder();
    System.out.println("sb:" + sb);
    System.out.println("sb.length():" + sb.length());
    //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
    StringBuilder sb2 = new StringBuilder("hello");
    System.out.println("sb2:" + sb2);
    System.out.println("sb2.length():" + sb2.length());
  }
}

public class StringBuilderDemo01 {
  public static void main(String[] args) {
    //创建对象
    StringBuilder sb = new StringBuilder();
    //public StringBuilder append(任意类型)：添加数据，并返回对象本身
    // StringBuilder sb2 = sb.append("hello");
    //
    // System.out.println("sb:" + sb);
    // System.out.println("sb2:" + sb2);
    // System.out.println(sb == sb2);
    // sb.append("hello");
    // sb.append("world");
    // sb.append("java");
    // sb.append(100);
    //链式编程
    sb.append("hello").append("world").append("java").append(100);
    System.out.println("sb:" + sb);
    //public StringBuilder reverse()：返回相反的字符序列
    sb.reverse();
    System.out.println("sb:" + sb);
  }
}