学习目标

1. 掌握String常用方法
2. 掌握StringBuilder、StringBuffer
3. 了解正则

1.String

● String是JDK中提前定义好的类型　其所在的包是java.lang ,String翻译过来表示字符串类型，也就是说String类中已经提前定义好了很多方法都是用来处理字符串的，所以String中常用的方法大家都要掌握；

先介绍下String 类的特点 :

• String是不可变的类，也就是说String对象是不可变的对象，那么什么叫不可变的对象我们稍后给大家解释
• 当给String引用重新赋值时, 执行的操作为: 在内存中创建一个新的字符串地址, 使引用指向新地址

1.1 层级

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
        
}

1.2 创建方法和常用构造

两种创建方式

1. 双引号直接赋值
2. 利用构造创建

//双引号直接赋值
//String用法的一种特例
   String 引用名 = "值";

常用构造

String(byte[] bytes) //使用IDE里面默认的编码方式
String(byte[] bytes, Charset charset) 
String(byte[] bytes, String charsetName) 
String(byte[] bytes, int offset, int length)  
//将字节数组数据使用指定的编码方式转换(解码)一个字符串对象


String(char[] value) 
String(char[] value, int offset, int count)         
//将字符数组数据转换成字符串对象

 String(StringBuffer buffer) 
 String(StringBuilder builder)    

案例：字节数组转String

private static void demo1() {

    //乱码: 编码方法至少有2种存在  保证编码方式统一
    //创建String类对象
    String s = "hello";

    byte[] bytes = {-26, -120, -111, -28, -69, -84};

    //String str1 = new String(bytes,);//解码  将看不懂的字节的数据转换成字符串
    //String str1 = new String(bytes, StandardCharsets.UTF_8);
    //String str1 = new String(bytes, "UTF_8");
    String str1 = null;
    try {
        str1 = new String(bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    //使用的是哪一种编码格式?
    //获得当前ide里面默认的编码格式  Charset 维护所有编码格式的
    System.out.println(Charset.defaultCharset());
    System.out.println(str1);//鎴戜滑
}

案例：字符数组转String

private static void demo2() {
    //将字符数组转换成String
    char[] chars = {97, 100, 'a', '1', '我'};
    String s = new String(chars);
    System.out.println(s);

    String s1 = new String(chars, 0, 3);
    System.out.println(s1);

}

1.3 常用方法

1.3.1 与数组相关的方法

1.byte[] getBytes()  
2.byte[] getBytes(Charset charset)  
3.byte[] getBytes(String charsetName)  
//将字符串的数组转换成字节符数组  (与编码格式有关)----> 编码  
    
4.char[] toCharArray()  
 //遍历字符数据
5.String[] split(String regex)  //分割  使用指定的字符串的数据对原字符串进行分割
6.String[] split(String regex, int limit)    
 //使用指定的正则模式分割字符串  

1.3.2 字符串搜索相关的方法

1. int	indexOf​(String str);//指定字符串第一次出现的索引位置  没有找到-1
2. int	indexOf​(String str, int fromIndex)//指定的索引开始  查询指定字符串第一次出现的索引位置  没有找到-1
    
    
3. int	lastIndexOf​(String str);// 指定字符串最后一次出现的索引位置  没有找到-1
4. int	lastIndexOf​(String str, int fromIndex);
// 指定的索引开始  查询指定字符串最后一次出现的索引位置  没有找到-1

1.3.3 提取字符串相关的方法

1.char charAt(int index)  //获得指定索引字符数据  index
private static void charatdemo() {
    String str = "hello";
    for (int index = 0; index < str.length(); index++) {
        System.out.println(str.charAt(index));
    }
}

2.String substring(int beginIndex)  //截取字符串   根据指定的索引截取原字符串部分数据
3.String substring(int beginIndex, int endIndex)  //包头不包尾
private static void substringdemo() {
    String filePath = "C:\\demo.\\a\\b\\a.txt";
    //查询最后一个\\的索引位置  lastIndexOf()
    String fileName = filePath.substring(filePath.lastIndexOf("\\")+1);
    System.out.println(fileName);

    //获得文件扩展名
    //文件上传  不同的用户传的文件名以及后缀都一样
    //A: C:\\a.jpg
    //B: D:\\a.jpg
    //上传到同一个目录---> 文件名重名的文件
//        System.currentTimeMillis()
    //System.out.println(UUID.randomUUID().toString());
    String extension = filePath.substring(filePath.lastIndexOf(".") + 1);
    System.out.println(extension);
    
    String str = "hello";
    System.out.println(str.substring(2, 4));

    //案例: 152****3456
    String phone = "15234567890";//长度固定的
    String begin = phone.substring(0,3);
    String end = phone.substring(7);
    String result = begin+"****"+end;
    System.out.println(result);
}

4.String toUpperCase()  //字母 转大写
5.String toLowerCase()  //字母 转小写
6.String trim() //去除空格
  String stripLeading()
  String stripTrailing()  

7.String concat(String str)  
8.static String join(CharSequence delimiter, CharSequence... elements) 
private static void demo12() {
        //模拟用户注册  将数据转换成:  id-name-pass-age
        Scanner input = new Scanner(System.in);
        int idIndex = 1001;
        System.out.println("录入name:");
        String name = input.next();

        System.out.println("录入pass:");
        String pass = input.next();

        System.out.println("录入age:");
        int age = input.nextInt();

        //将id name age pass 转换成指定格式
        //id-name-pass-age
        //String info = idIndex + "-" + name + "-" + pass + "-" + age;
        //System.out.println(info);

        //String concat(str)  类似+
        //String concat = String.valueOf(idIndex++).concat("-").concat(name).concat("+").concat(pass).concat("-").concat(String.valueOf(age));
        //String.join();
        String info = String.join("-", String.valueOf(idIndex), name, pass, String.valueOf(age));
        System.out.println(info);
        input.close();
    }

9.String repeat(int count)  

1.3.4 可变长参数

public static void main(String[] args) {
        //调用的时候 传递参数0个
        method();
        //调用的时候 传递多个参数
        method("aa", "bb");
    }
    /**
     * 如何定义可变长参数 任意数据类型...
     * 注意点：若方法中包含可变长参数，则必须出现在最后
     * 在方法内部，把可变长参数当成数组来进行使用
     * 调用的时候 可传值  0或多个都可以
     * @param a
     */
    public static void method(String... a) {
        System.out.println(a);
        // 在方法内部，把可变长参数当成数组来进行使用
        System.out.println(a.length);
        System.out.println(Arrays.toString(a));
    }

1.3.5 比较判断方法相关的方法

1.int compareTo(String anotherString)  //比较2个字符串是否相等  返回值: 0 正整数 负整数
    
2.int compareToIgnoreCase(String str) //不区分大小写比较2个字符串是否相等  返回值: 0 正整数 负整数 
    
    
3.boolean contains(CharSequence s)  //判断字符串是否包含指定字符串
4.boolean equals(Object anObject)  //比较2个字符串是否相等
5.boolean equalsIgnoreCase(String anotherString)  //不区分大小写比较2个字符串是否相等
    
6.boolean endsWith(String suffix)  //判断字符串是否以指定字符串结尾
7.boolean startsWith(String prefix)  //判断字符串是否以指定字符串开头
    
8.boolean isEmpty()  //判断字符串是否是空 ""  length==0
    
9.boolean isBlank()  //判断字符串是否是空 ""  "   "  length==0
    
10.boolean matches(String regex)   

1.3.6 替换相关的方法

1.String replace(char oldChar, char newChar)  //使用指定的字符的数据替换原字符串里面指定的所有的字符
2.String replace(CharSequence target, CharSequence replacement)  
    //使用指定的字符串的数据替换原字符串里面指定的所有的字符串
    
3.String replaceAll(String regex, String replacement)   
4.String replaceFirst(String regex, String replacement)     
    
 // 使用字符串替换满足正则语法模式要求的字符串的数据   

1.4 运行时常量池（串池）

● 字符串是使用的最频繁的类型，如果每次使用字符串对象，都用new关键字进行创建，那么堆内存中就会出现大量的字符串对象而占用大量堆空间；
● 为了提高JVM对字符串操作的内存使用率，JVM在方法区中提供了一块区域专门用于存储字符串字面量，这块区域位于方法区的运行时常量池；
● 当直接把字面量 赋值给字符串引用的时候， JVM会先去常量池中找这个字符串对象是否存在，如果存在直接返回此对象的地址 否则就会新建一个字符串对象 然后返回这个对象的内存地址；
● 如果+两边都是常量，查询规则还是先去常量池中找字符序列是否存在，如果存在直接返回地址 否则就新建对象；
● 如果+两边一旦有变量,拼接后的字符串对象是先存放在一个缓冲区中 并没有在常量池中

/**
     * 常量池 在方法区中 ：里面放的是字符序列
     */
    public static void method9() {
        String str1 = "java";
        // 如果存在字面量 直接返回地址
        String str2 = "java";
        String str3 = "javaSun";
        String str4 = "javaSun";
        String str5 = "java" + "Sun"; // 如果+两边都是常量，查询规则还是先去常量池中找字符序列是否存在，如果存在直接返回地址 否则就新建对象
        String str6 = str1 + "Sun"; //  如果+两边一旦有变量,拼接后的结果是存放在一个缓冲区中 没有在常量池中
        // new 都在堆空间
        /*String str3 = new String("java");
        String str4 = new String("java");*/
        System.out.println("equals1:" + (str1 == str2));
//        System.out.println("equals2 :" + (str1 == str3));
        System.out.println("+两边有常量了" + (str5 == str4));
        System.out.println("+两边有变量了" + (str6 == str4));
    }

• intern(): 其功能可以做到 在运行期间 把字符对象放入常量池

private static void demo17() {

    //并发里面 充当锁对象

    String str1 = "hello";
    String intern1 = str1.intern();
    System.out.println(str1 == intern1);//true

    String str2 = new String("hello");
    String intern2 = str2.intern();
    System.out.println(str1 == str2);//false
    System.out.println(str2 == intern2);//false
    System.out.println(str1 == intern2);//true
}

1.5 字符串不可变性

• 对象内部的成员变量的值是不可变的因此是不可变的类型，使用final修饰了！

1.6 总结String两种创建方式的区别

1. 双引号直接赋值: 直接使用串池. 先在串池中查找是否存在指定内容, 存在则直接指向, 不存在则先在串池中创建后指向
2. 利用构造创建: 间接使用串池. 无论如何都会开辟对象空间, 再去串池中查找指定内容, 存在则直接存储串池地址, 不存在则先在串池中创建后存储该地址

		String str1 = "abc";
        String str2 = "abc";

        System.out.println(str1 == str2);//t 串池地址相同

        String s1 = new String("edf");
        String s2 = new String("edf");

        String str3 = "edf";

        System.out.println(s1 == s2);//f 对象地址不同
        System.out.println(s1 == str3);//f 对象地址 != 串池地址

2.StringBuffer/StringBuilder

• StringBuffer/StringBuilder也是用来处理字符串的，因此方法和String方法非常类似；
• 并非常量, 值可变
• StringBuffer : JDK1.0 线程安全,效率低
• StringBuilder :JDK5.0 线程不安全, 效率高
  这两个类的方法一模一样

2.1 层级

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuilder>, CharSequence{}

 public final class StringBuffer
    extends AbstractStringBuilder
    implements Serializable, Comparable<StringBuffer>, CharSequence{}

2.2 特点

1. 不能使用串池

2. 必须通过构造创建

3. 必须调用方法操作字符串内容, 无法使用运算符

2.3 常用方法

   1. append(值): 在末尾追加内容
   2. insert(index,str); 在指定的索引位置 插入字符串数据
   3. delete(startIndex,endIndex)  删除从startIndex到endIndex的字符串的数据  包头不包尾
   4. deleteCharAt(index) 删除指定索引的字符数据
   5. insert(index,str); 在指定的索引位置 插入字符串数据
   6. replace(startIndex,endIndex,newStr)  使用newStr替换从startIndex到endIndex的字符串的数据  包头不包尾
   7. reverse(): 内容反转

2.4 对比

类名	值是否可变	线程安全	性能	内存(拼接)
String	不可变	安全(final)	其次	+ new 占据更多内存
StringBuffer	可变	安全(synchronized)	最后	只有1个对象
StringBuilder	可变	不安全	最快	只有1个对象

2.5 与String的相互转换

1. String 转 可变长字符串

 
   StringBuilder 引用名 = new StringBuilder(String引用名 | "值");

2. 可变长字符串 转 String

   String 引用名 = StringBuilder引用名.toString();

		String str = "abc";
        //转为可变长字符串
        StringBuilder sb = new StringBuilder(str);

        //转String
        String str2 = sb.toString();

当对String进行运算符操作时, 如+=, 会在底层中将其转换为StringBuilder完成操作, 再将StringBuilder转换回String

String s1 = "abcdefg";
String s2 = "abcd";

 s2 += "efg";//先将s2内容转换进StringBuilder, 在SB中完成拼接操作, 再转换回String

 System.out.println(s1 == s2);//f

 //以下动作不会操作StringBuilder
 String str = "abc";
 str = "edf";
 str = "123"; 

3 正则表达式

● 能够读懂即可，一般在前端的js，校验数据。(判断用户客户端提交的数据是否满足正则要求)
● 后端编程语言 java也是支持正则匹配

3.1 概念

● 正则表达式，又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE），是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"），是计算机科学的一个概念。
● 正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串，
● 通常被用来检索、替换那些符合某个模式（规则）的文本

String类的方法中: 支持正则编写。
 1.  String[] split(String regex,int limit); //根据正则模式要求分割源字符串的数据
 2.  boolean  matches(String regex); //检索/判断字符串的数据(文本数据)是否满足正则模式的要求。
 3.  String replaceAll(String regex,String replacement);
      //使用replacement替换原字符串中满足正则模式要求的文本数据
     String replaceFirst(String regex,String replacement);
      // 使用replacement替换原字符串中第一个满足正则模式要求的文本数据

3.2 语法

● 参考正则在线手册: https://tool.oschina.net/uploads/apidocs/jquery/regexp.html
● 语法: String regx = “^([]{})([]{})([]{})([]{})$”;
● ^：可以省略。以xxx开头。
● $：可以省略。以xxx结尾。
● (): 可以省略。代表的是一个组/域。简称域段。域和域之间没有关系的。正则模式里面: \n代表第n个域。从1开始。一般用于执行"替换功能"的时候，域段必须编写的。动态的获得第n个域里面的内容作为替换内容的话 $n
● []：可以省略。编写限定的字符数据。[a-zA-Z0-9_]{1}
● {}: 可以省略。 限定[]里面字符内容的次数。[ab]{1,3} {正整数}
● : 转义符号
● : 匹配前面的子表达式零次或多次 [a]{0,} [a] a*
● +: 匹配前面的子表达式一次或多次 [a]{1,} a{1,} a+
● .: 匹配除“\n”之外的任何单个字符 [.]{1} 匹配任意一个字符
● x|y: 匹配x或y
● [xyz]: 匹配所包含的任意一个字符 [a-z]{1} [A-Z]{1} [0-9]{1} \d 等价于[0-9] \d{1}
● \s: 匹配的是空白字符 \s+ 匹配字符串里面出现>=1次的空格内容
● \w: 等价于[A-Za-z0-9_]

4.String方法汇总

5.StringBuilder方法总结