String的基本用法

package _2String类;

import java.util.Arrays;

public class StringDemo {

    public static void main(String[] args) 
    {
        
        
        // 1. 创建字符串
        createString();
        
        // 2. 字符串的内存问题
        memory();
        
        // 3. 字符串的比较
        compare();
        
        // 4. 转换
       trans();
        
        // 5. 操作
        op();
        
        
        
    
    }

    private static void op() {
        
        
        // 1. 连接字符串
        String s1 = "Hello";
        String s2 = "world";
        String result = s1+s2;
        String result = s1.concat(s2);// concat 返回了一个新的字符串
        System.out.println(result);
        System.out.println(s1);
        System.out.println(s2);

        String result = s1.concat(s2).concat(" java").concat(",c++");// 链式编程
        System.out.println(result);
        
        // 2. 查找
         int indexOf(int ch) 
        //返回指定字符在此字符串中第一次出现处的索引。 
        int indexOf(int ch, int fromIndex) 
       // 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 
         int indexOf(String str) 
         //返回指定子字符串在此字符串中第一次出现处的索引。 
         int indexOf(String str, int fromIndex) 
         //返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 
        
         int lastIndexOf(int ch) 
         //返回指定字符在此字符串中最后一次出现处的索引。 
         int lastIndexOf(int ch, int fromIndex) 
         //返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 
         int lastIndexOf(String str) 
        // 返回指定子字符串在此字符串中最右边出现处的索引。 
         int lastIndexOf(String str, int fromIndex) 
         //返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 

        String str = "asdaaafasdaaaf23423423dcasdf2354aaaf2334";
        System.out.println(str.indexOf("aaa"));
        System.out.println(str.lastIndexOf("aaa"));// 从后往前找
        System.out.println(str.indexOf("xxx"));// -1 找不到
        System.out.println(str.indexOf("aaa",7));// 10

        //3. 替换

         String replace(char oldChar, char newChar) 
         //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 
         String replace(CharSequence target, CharSequence replacement) 
         //使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 
         String replaceAll(String regex, String replacement) 
         //使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
         String replaceFirst(String regex, String replacement) 
         //使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
        String str = "asdaaafasdaaaf23423423dcasdf2354aaaf2334";
        String result = str.replace("aaa", "AAA");
        System.out.println(result);
        System.out.println(str);
        
        
        // 4. 去空格
        // trim()
        
        // 常见的就是用户在网页上填写信息的时候,两边多敲了空格
        String s = " qiang asdfasdfasdf 234234234      ";
        String result = s.trim();
        System.out.println(s);
        System.out.println(result);
        
        // 5 分割
        String s = "Java|C#|Python|Kotlin|Swift";
        String[] sArr= s.split("\\|");// 分割|需要用 \转义
        
       for(int i=0;i<sArr.length;i++)
        {
            System.out.println(sArr[i]+"语言");
       }
        
        // 6. 得到子字符串
        String substring(int beginIndex) 
        //返回一个新的字符串，它是此字符串的一个子字符串。 
        String substring(int beginIndex, int endIndex) 
        //返回一个新字符串，它是此字符串的一个子字符串。
        
        String s = "abcdefg";
        System.out.println(s.substring(3));// defg
        System.out.println(s.substring(2, 2+4));


    }

    private static void trans() 
    {
         char[] toCharArray() 
         //将此字符串转换为一个新的字符数组。 
         String toLowerCase() 
         //使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 
         String toLowerCase(Locale locale) 
         // 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 
         String toString() 
         //返回此对象本身（它已经是一个字符串！）。 
         String toUpperCase() 
         //使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 
         String toUpperCase(Locale locale) 
          //使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 


        // 转换为字符数组
         String str = "Hello";
        char[] ch = str.toCharArray();
        System.out.println(ch[1]);
        System.out.println(Arrays.toString(ch));
        
        System.out.println(str.toLowerCase());
        System.out.println(str.toUpperCase());
    }

    private static void compare() {

         boolean equals(Object anObject) 
         // 将此字符串与指定的对象比较。 

          boolean equalsIgnoreCase(String anotherString) 
        //  将此 String 与另一个 String 比较，不考虑大小写。
        
          int compareTo(String anotherString) 
          // 按字典顺序比较两个字符串。 
          int compareToIgnoreCase(String str) 
          //按字典顺序比较两个字符串，不考虑大小写。 

        System.out.println("abc".equals("cba"));// false
        System.out.println("abc".equals("abc"));// true
        System.out.println("abc".equals("ABC"));// false
        System.out.println("abc".equalsIgnoreCase("ABC"));// true
        
        String str = "abc";
        System.out.println(str.compareTo("abc"));// 0
        System.out.println(str.compareTo("aaa"));// 1    b-a 
        System.out.println(str.compareTo("acc"));// -1  b-c
        System.out.println(str.compareTo("azc"));//     b-z = -24
        
        // 3. 判断包含 开头 结尾
         boolean contains(CharSequence s) 
       //  当且仅当此字符串包含指定的 char 值序列时，返回 true。 
         boolean startsWith(String prefix) 
       // 测试此字符串是否以指定的前缀开始。 
           boolean endsWith(String suffix) 
       // 测试此字符串是否以指定的后缀结束。 
        
        String s10 = "Demo1.java";
        System.out.println(s10.contains(".java"));// true
        System.out.println(s10.contains(".jeee"));// false
        
        System.out.println(s10.startsWith("Demo"));// true
        System.out.println(s10.endsWith(".java"));
    }

    private static void memory() {
        
        
        String s1 = "Hello";// 字符串常量对象    存放在字符串的常量池中
        String s2 = "Hello";
        String s3 = new String("Hello");// new在堆区创建新的对象
        String s4 = new String("Hello");
        
        System.out.println(s1 == s2);// true
        System.out.println(s1 == s3);// false
        System.out.println(s3 == s4);// false
        
        System.out.println("哈哈");
        
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s4.equals(s3));
        
        
        String s5 = "Hello";// s5 指向了常量池中的 字符串常量对象
        s5 = s5 + "world";// 在堆区新建一个字符串对象 存放 Hello world
        s5 = s5 + "!";// 又在堆区新建一个字符串对象 存放 Hello world!
        System.out.println(s5);
        
        // String对象是不可变量
        // 但是String引用变量 可以指向新的对象
        
        
        String s7 = "igeek";
        String s8 = "home";
        String s9 = "igeekhome";
        System.out.println(s9 == "igeekhome");// true
        System.out.println(s9 == (s7+s8));// false
        System.out.println(s9 == "igeek"+"home");// true 编译器进行了优化 将""
        
    }

    private static void createString() 
    {
        
        String str1 = new String();
        String str2 = "";
        String str3 = null;
        
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);// null
        
        System.out.println(str1.length());// 0
        System.out.println(str2.length());// 0
        System.out.println(str3.length());
        // Exception in thread "main" java.lang.NullPointerException

        
        char[] ch = {'H','e','l','l','o'};
        String str4 = new String(ch);
        String str5 = String.valueOf(ch);
        String str6 = new String(ch,2,3);// el
        System.out.println(str6);
        
        byte[] bytes = {104,111,109,101};// ASCII    home
        String str7 = new String(bytes);
        System.out.println(str7);
    }

}