Java的String

String
    1.字符串 : 字符序列
        String : 不可变的字符序列
        StringBuilder :  可变的字符序列,线程不安全|不同步的
        StringBuffer :  可变的字符序列,线程安全|同步的
        执行效率 : StringBuilder > StringBuffer > String
        常用频率 : String > StringBuilder > StringBuffer
        三者区别 : 
            1)是否可变 
            2)线程安全
            3)执行效率
    2.String : String类表示字符串。
         Java 程序中的所有字符串文字
            例如"abc" ，都是作为此类的实例实现的。
        String的对象的表示方式 :
            1.字符串文字  "...." -->在字符串常量池中
                String s1 = "xxx";
            2.new 创建String类型对象-->在堆内存中
                 String s2 = new String("xxx");
    3.String 底层结构 :
         jdk8及之前版本 :  private final char value[];
        jdk8之后 : private final byte[] value;
    4.String常用类
        初始化一个新创建的String对象，使其表示一个空字符序列。
             String s1 = new String();
        初始化一个新创建的String对象，使其表示与参数相同的字符序列； 换句话说，新创建的字符串是参数字符串的副本。
            String(String original)
        分配一个新字符串，该字符串包含字符串缓冲区参数中当前包含的字符序列。
            String(StringBuffer buffer)
        分配一个新字符串，该字符串包含字符串构建器参数中当前包含的字符序列。
            String(StringBuilder builder)
        分配一个新的String以便它表示当前包含在字符数组参数中的字符序列。
            String(char[] value)
            
                
        分配一个新的String ，其中包含来自字符数组参数的子数组的字符
            String(char[] value, int offset, int count)
            
                
        通过使用平台的默认字符集解码指定的字节数组来构造一个新的String 。
            String(byte[] bytes)
            
                
            gbk->1个汉字2个字节 
            utf-8->1个汉字3个字节
            System.out.println(new String(arr)); //默认UTF-8
        通过使用指定的String解码指定的字节数组来构造一个新的String 。
            String(byte[] bytes, String charsetName)
            
                
        通过使用平台的默认字符集解码指定的字节子数组来构造一个新的String 。
            String(byte[] bytes, int offset, int length)
        通过使用指定的字符集解码指定的字节子数组来构造一个新的String 。
            String(byte[] bytes, int offset, int length, String charsetName)
            
                
    5.String常用方法 :
        String str1 = "jintiannikuailema";
        String str2 = "Jintiannikuailema";
        char charAt(int index) 
            返回指定索引处的char值。
             System.out.println(str1.charAt(5));
                
        int codePointAt(int index)
            返回指定索引处的字符（Unicode 代码点）。
            System.out.println(str1.codePointAt(5));
                
        int codePointBefore(int index)
            返回指定索引之前的字符（Unicode 代码点）。
             System.out.println(str1.codePointBefore(6));
                
        int compareTo(String anotherString)
            按字典顺序比较两个字符串。
                返回值  :
                     0 : x=y
                    <0 : x<y
                    >0 : x>y
            System.out.println(str1.compareTo(str2));
                
                
        int compareToIgnoreCase(String str)
            按字典顺序比较两个字符串，忽略大小写差异。
            System.out.println(str1.compareToIgnoreCase(str2));
                  
        String concat(String str)
            将指定的字符串连接到此字符串的末尾。
            System.out.println(str1.concat(str2));
                
        boolean contains(CharSequence s)
            当且仅当此字符串包含指定的 char 值序列时才返回 true。
            System.out.println("王鹏".contains("鹏"));
                
        boolean equals(Object anObject)
            将此字符串与指定对象进行比较。
             System.out.println(str1.equals(str2));
                
        boolean equalsIgnoreCase(String anotherString)
            将此String与另一个String进行比较，忽略大小写考虑。
            System.out.println(str1.equalsIgnoreCase(str2));
                
        boolean endsWith(String suffix)
            测试此字符串是否以指定的后缀结尾。
        boolean startsWith(String prefix)
            测试此字符串是否以指定的前缀开头。
             System.out.println("王鹏".startsWith("王"));
                
        boolean startsWith(String prefix, int toffset)
            测试从指定索引开始的此字符串的子字符串是否以指定前缀开头。
            System.out.println("张鹏王鹏".startsWith("王",2));
                
        byte[] getBytes(String charsetName)
            使用命名字符集将此String编码为字节序列，并将结果存储到新的字节数组中。
        byte[] getBytes()
            使用平台的默认字符集将此String编码为字节序列，并将结果存储到新的字节数组中。
        char[] toCharArray()
            将此字符串转换为新的字符数组。
            System.out.println(Arrays.toString(str1.toCharArray()));
                
        void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
            将此字符串中的字符复制到目标字符数组中。
            
                
        int indexOf(String str)
            返回此字符串中第一次出现指定子字符串的索引。
            System.out.println(str1.indexOf("a"));
                
        int indexOf(String str, int fromIndex)
            返回此字符串中第一次出现指定子字符串的索引，从指定索引开始。
            System.out.println(str1.indexOf("a",6));
                
        int lastIndexOf(String str)
            返回此字符串中最后一次出现指定子字符串的索引。
            System.out.println(str1.lastIndexOf("a"));
                
        int lastIndexOf(String str, int fromIndex)
            返回此字符串中指定子字符串最后一次出现的索引，从指定索引开始向后搜索。
            System.out.println(str1.lastIndexOf("a",11));
                
            ystem.out.println("hahaabcheheabchouhouabc".lastIndexOf("abc"));
                
                    System.out.println("hahaabcheheabchouhouabc".lastIndexOf("abc",12)); //如果正处于一个子串的中间,往前查找可以找到当前子串
                
        int length()
            返回此字符串的长度。
            System.out.println("abc".length());
                
        String repeat(int count)
            返回一个字符串，其值为该字符串重复count次的串联。
             System.out.println("abc".repeat(3));
                
        String replace(char oldChar, char newChar)
            返回一个字符串，该字符串是用newChar替换此字符串中所有出现的oldChar得到的。
        String replace(CharSequence target, CharSequence replacement)
            用指定的文字替换序列替换此字符串中与文字目标序列匹配的每个子字符串。
        String replaceAll(String regex, String replacement)
            用给定的替换替换此字符串中与给定regular expression匹配的每个子字符串。
            System.out.println(str1.replaceAll("a","A"));
                
        String replaceFirst(String regex, String replacement)
            用给定的替换替换此字符串中与给定的regular expression匹配的第一个子字符串。
             System.out.println(str1.replaceFirst("a","A"));
                
        String[] split(String regex)
            围绕给定regular expression的匹配拆分此字符串。
            System.out.println(Arrays.toString("name=zhangsan&pwd=123&age=18".split("&")));
                
        String strip()
            返回一个字符串，其值为该字符串，删除所有前导和尾随white space 。
        String stripLeading()
            返回一个字符串，其值为该字符串，所有前导white space已删除。
        String stripTrailing()
            返回一个字符串，其值为该字符串，并删除所有尾随white space 。
        String trim() -->半角空格
            返回一个字符串，其值为该字符串，删除了所有前导和尾随空格，其中空格定义为代码点小于或等于'U+0020' （空格字符）的任何字符。
            全角空格了(“　”)    半角空格(“ ”)
            System.out.println("　haha ".trim());
                
                    System.out.println("　haha ".strip());
                
                    System.out.println("　haha ".stripLeading());
                
                    System.out.println("　haha ".stripTrailing());
                
        String substring(int beginIndex)
            返回作为此字符串的子字符串的字符串。
            System.out.println(str1.substring(5));
                
        String substring(int beginIndex, int endIndex)
            返回作为此字符串的子字符串的字符串。
             System.out.println(str1.substring(5,8));
                
        String toLowerCase()
            使用默认语言环境的规则将此String中的所有字符转换为小写。
            System.out.println(str1.toUpperCase());
                
        String toUpperCase()
            使用默认语言环境的规则将此String中的所有字符转换为大写。
            System.out.println(str2.toLowerCase());
                
        static String valueOf(boolean b)
            返回boolean参数的字符串表示形式。
             System.out.println(String.valueOf(false));;
                
    6.String 对象比较等问题 :
         String s = "aaa";  //堆内存中
        String ss = new String("aaa");  //new堆内存
        //编译期间  : 对表达式进行优化->如果表达式中都是常量参与运算,编译期间就会进行运算
    7.StringBuilder 与 StringBuffer :
        StringBuffer :  一个线程安全的、可变的字符序列。字符串缓冲区类似于String ，但可以修改。字符串缓冲区可以安全地被多个线程使用。
         StringBuilder : 可变的字符序列。 此类提供与StringBuffer兼容的 API，但不保证同步。
        通常应该优先使用StringBuilder类而不是这个类，因为它支持所有相同的操作，但速度更快，因为它不执行同步。
        从 JDK 5 开始，这个类已经补充了一个为单线程使用而设计的等效类StringBuilder 。 
        学习 :
             1.StringBuilder 与 StringBuffer对象创建方式
            2.StringBuilder 与 StringBuffer底层结构与扩容问题
                底层结构 : 来自于父类AbstractStringBuilder的成员  :
                    jdk8及之前版本 :  char[] value;
                    jdk8之后 : byte[] value;
                 扩容机制 : 
                    每次扩容原容量的2倍+2    int newLength = oldLength + oldLength + 2
             3.StringBuilder 与 StringBuffer 常用方法
            4.StringBuilder|StringBuffer与String之间相互转换问题
                StringBuilder|StringBuffer-->String
                    1)StringBuilder|StringBuffer的toString
                    2)new String(StringBuilder|StringBuffer)
                 String-->StringBuilder|StringBuffer
                     1) new StringBuilder|StringBuffer(String)
         注意 :
            如果某个类型的底层结构涉及到数组的使用,需要关注数组的初始容量+扩容机制
        常用方法：
            StringBuilder()
                构造一个其中没有字符且初始容量为 16 个字符的字符串构建器。
                
            StringBuilder(String str)
                构造一个初始化为指定字符串内容的字符串构建器。
                
            StringBuilder(int capacity)
                构造一个字符串构建器，其中没有字符，初始容量由capacity参数指定。
                
            StringBuilder append(boolean b)
                将boolean参数的字符串表示形式附加到序列中。
                
            StringBuilder delete(int start, int end)
                删除此序列的子字符串中的字符。
                
            StringBuilder insert(int offset, boolean b)
                将boolean参数的字符串表示形式插入此序列。
                
            StringBuilder replace(int start, int end, String str)
                将此序列的子字符串中的字符替换为指定的String中的字符。
                
            StringBuilder reverse()
                导致此字符序列被相反的序列替换。
                
     以下代码是否存在对象,存在几个,分别在内存的什么位置?
            String s1 = "abc";   1个  字符串常量池中"abc"
            String s2 = new String("haha");  2个   new->堆内存中    "haha"-->字符串常量池中
            String s3 = new String("abc"); 1个  new->堆内存中