16 String类

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容结束------------

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容结束------------

------------恢复内容结束------------

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容结束------------

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容开始------------

java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象

eg：

    String str = new String();
    str = "123";
    str = "abc";    

String类的特点：

     1.字符串字面值常量，不变的
     2.实现共享
     3.内部封装了很多对于字符和字符串操作的API方法
     4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
     5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
     通过StringBuilder中的append方法实现的（把两种类型相加）
     字符串转换通过toString方法实现的（变为字符串）
      true +"" --> "true"
      123 + "" -->  "123"
      3.14 + ""--> "3.14"

String类的常用用法以及使用格式：

序号旁边的是使用格式

    //1.charAt(int index )返回指定索引处的字符值

　　　　　　String str = "abcds";
　　　　　　char sss = str.charAt(3);
　　　　　　System.out.println(sss);

char ssss = str.charAt(6);这个索引越界
        System.out.println(ssss);
　　　　　//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
　　　　　//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，


    //2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
　　　　　String str = "aBbcds"
        int codePointAt = str.codePointAt(1);
        System.out.println(codePointAt);// B  -->66  b-->98(根据阿斯克码表)
        

　　//3.compareTo(String str)
        int compareTo = str2.compareTo(str);
        //this.charAt(k)-anotherString.charAt(k)
        //this.length()-anotherString.length()
        System.out.println(compareTo);
    //4.compareToIgnoreCase(String str) 忽视大小写比较字符串
        int compareToIgnoreCase = str2.compareToIgnoreCase(str);
    //5.concat(String str)    
        String concat = str.concat(str2);
        System.out.println(concat);// Abc123afg123
    //6.Contains(CharSequence s)   [重要]
        boolean contains = str2.contains("f23");//  f23是一个整体不可分割
        System.out.println(contains);//true  false 
    //7.endsWith(String suffix )     suffix 后缀       prefix   前线
        boolean endsWith = str2.endsWith("23");
        System.out.println(endsWith);
    //8 starsWith(String prefix) [重要]  是否以某个字符串为结尾          
        boolean StartsWith = str2.startsWith("afg");
        System.out.println(StartsWith);
    //9. 相等判断equals(Object o) 重要  相等判断
        boolean equals = str.equals(str2);
        System.out.println(equals);
    //10.getBytes() byte[]    "afg123"
        byte[] bytes = str2.getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i] + " ");
        }
        //  UTF-8   GBK  ISO-8859-1  Unicode
        
        //src 来源    dst 目的地
          char[] dst = new char[10];//  10个元素  （没有东西）
    //11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
          //"afg123"
        str2.getChars(2, 5, dst,4);//第五个位置
        for (int i = 0; i < dst.length; i++) {
            System.out.println(dst[i] + " ");
        }
        //str2 = "afg123"
    //12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
        int indexOf = str2.indexOf("12");//
        System.out.println(indexOf);// 3
    //13. int  length()获取字符串的长度值    【重要】    
        int length = str2.length();
        System.out.println(length);
    //14.replace(CharSequence target, CharSequence replacement)
        String replace = str2.replace("a", "e");//  把旧的字符串替换成新的字符串
        System.out.println(replace);//ebc123ebc456
    //15. split(String regex)根据指定的字符分割成字符串数组【重要】
        //regex - 定界正则表达式
        String str4 = "张三-李四-王五-赵六-abc";
        String[] split = str4.split("-");
        //相当于split = {"张三","李四","王五","赵六","abc"}
        for (int i = 0; i < split.length; i++) {
            System.out.print(split[i] + " ");
        }
        System.out.println();
        String str5 = "abc.bcd.fff.123";
        String[] split2 = str5.split("\.");// 用.分割的话需要用需要用双反斜杠
        // ---反斜杠    /---正斜杠  在字符串中""代表转义
        for (int i = 0; i < split2.length; i++) {
            System.out.print(split2[i] + " ");// abc bcd fff 123
        }
        
        System.out.println();
        String str6 = "123456789abc";
        String[] split3 = str6.split("");//空字符串做分隔符
        for (int i = 0; i < split3.length; i++) {
            System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
        }
        
    //16.substring(int beginIndex,int endIndex) [a,b)  截取字符串 生成一个新的字符串
        // 获取str6字符串中6789值
        String substring = str6.substring(5, 9);
        System.out.println(substring);
        
    //17. toLowerCase()小写     toUpperCase()大写
    //18.String trim(() 去掉该字符串前后两端的空格
        String str7 = " abc  123 ";
        System.out.println("--"+str7+"--");
        String trim = str7.trim();
        System.out.println("--"+ trim + "--");
    //19. static valueOf(Object o)  把非字符串类型转换成字符串类型，内容值不变
        String valueOf = String.valueOf(abc);
        System.out.println(valueOf);//123

------------恢复内容结束------------

------------恢复内容结束------------

------------恢复内容结束------------