package com.lovecoding.day17.api;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class TestString {

    //（32）String[] split(正则)：按照某种规则进行拆分
    @Test
    public void test12(){
        String s1 = "h.e.llo.wor.ld";
        String s2 = "h[e[llo[wor[ld";
        String[] split1 = s1.split("\\.");
        String[] split2 = s2.split("\\[");
        System.out.println(Arrays.toString(split1));
        System.out.println(Arrays.toString(split2));

        String[] os = s1.split("o");
        System.out.println(Arrays.toString(os));
    }


    //（29）String replace(xx,xx)：不支持正则
    //（30）String replaceFirst(正则，value)：替换第一个匹配部分
    //（31）String repalceAll(正则， value)：替换所有匹配部分
    @Test
    public void test11(){
        //String replace(xx,xx)：不支持正则
        String a1 = "Process finished with exit code 0";
        String code = a1.replace("code", "");
        System.out.println(code);

        //String replaceFirst(正则，value)：替换第一个匹配部分
        String a2 = "替换第一个匹配部分,替换所有匹配部分";
        String s = a2.replaceFirst("替换", "aaaaa");
        System.out.println(s);

        //String repalceAll(正则， value)：替换所有匹配部分
        String a3 = " hello world ";
        String s1 = a3.replaceAll(" ", "");
        System.out.println(s1);

    }

    //boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式
    @Test
    public void test10(){
        //qq要求 5-11位 数字组成  第一位 1-9
        String qq = "5678";
        //第一位1-9 第2位 第11位 0-0组成
        String reg = "[1-9][0-9]{4,10}+";

        System.out.println(qq.matches(reg));
    }

    /*
    （26）boolean startsWith(xx)：是否以xx开头
    （27）boolean endsWith(xx)：是否以xx结尾
     */
    @Test
    public void test09(){
        String s1 = "中国歩军天下无敌,中国空军世界前列";
        System.out.println(s1.startsWith("中国"));
        System.out.println(s1.endsWith("世界"));

    }

    /*
    （11）boolean contains(xx)：是否包含xx
    （12）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
    （13）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1
     */
    @Test
    public void test08(){
        //boolean contains(xx)：是否包含xx
        System.out.println("helloworld".contains("h"));
        System.out.println("helloworld".contains("a"));

        //int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1
        String  s1 =  "中国歩军天下无敌,中国空军世界前列";
        System.out.println(s1.indexOf("中国"));
        //截取第一个中国
        String substring = s1.substring(s1.indexOf("天下"), "中国".length() + s1.indexOf("天下"));
        System.out.println(substring);

        System.out.println(s1.lastIndexOf("中国"));
    }

    /*
    （24）byte[] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码方式进行编码
        byte[] getBytes(字符编码方式)：按照指定的编码方式进行编码
   （25）new String(byte[] ) 或 new String(byte[], int, int)：解码，按照平台默认的字符编码进行解码
       new String(byte[]，字符编码方式 ) 或 new String(byte[], int, int，字符编码方式)：解码，按照指定的编码方式进行解码
     */
    @Test
    public void test07() throws UnsupportedEncodingException {
        byte[] bytes = "中国".getBytes();
        byte[] bytes1 = "中国".getBytes(StandardCharsets.ISO_8859_1); //ISO_8859_1 不能存储中文

        String s = new String(bytes);
        System.out.println(s);

        System.out.println(Arrays.toString(bytes));
        String s1 = new String(bytes1,StandardCharsets.ISO_8859_1);//
        System.out.println(s1);

        //GBK  两个字节  UTF8 三个字节
        byte[] bytes2 = "中国".getBytes(); //u8
        System.out.println(Arrays.toString(bytes));
        byte[] gbks = "中国".getBytes("GBK");//GBK
        System.out.println(Arrays.toString(gbks));
    }
    /*
    （16）char charAt(index)：返回[index]位置的字符
    （17）char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
    （18）String(char[] value)：返回指定数组中表示该字符序列的 String。
    （19）String(char[] value, int offset, int count)：返回指定数组中表示该字符序列的 String。
    （20）static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
    （21）static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
    （22）static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
    （23）static String valueOf(char[] data)  ：返回指定数组中表示该字符序列的 String
     */
    @Test
    public void test06(){
        String s = "helloworld";
        //char charAt(index)：返回[index]位置的字符
        char c = s.charAt(3);
        System.out.println(c);
        //char[] toCharArray()： 将此字符串转换为一个新的字符数组返回
        char[] chars = s.toCharArray();
        System.out.println(Arrays.toString(chars));

        //static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
        String s1 = "helloworld";
        char[] chars1 = s1.toCharArray();
        String s2 = String.copyValueOf(chars1);
        String s3 = String.copyValueOf(chars1,0,2);
        System.out.println(s2);
        System.out.println(s3);

    }

    @Test
    public void test05(){
        //#### 字符串截取
        //（14）String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
        //（15）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个
        String substring = "abcdefg".substring(2);
        System.out.println(substring);

        String a = "helloworld";
        String substring1 = a.substring(4, 7);
        System.out.println(substring1);

        //截取 a 字符串 从3开到最后
        String a1 = "helloworld"; // l = 10

        String substring2 = a1.substring(3, a1.length());
        System.out.println(substring2);
    }

    /*
      (1)  boolean isEmpty()：字符串是否为空
    （2）int length()：返回字符串的长度
    （3）String concat(xx)：拼接，等价于+
    （4）boolean equals(Object obj)：比较字符串是否相等，区分大小写
    （5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
    （6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
    （7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写
    （8）String toLowerCase()：将字符串中大写字母转为小写
    （9）String toUpperCase()：将字符串中小写字母转为大写
    （10）String trim()：去掉字符串前后空白符
    （11）public String intern()：结果在常量池中共享
     */
    @Test
    public void test04(){
        String s1 = "a";
        //boolean isEmpty()：字符串是否为空
        System.out.println(s1.isEmpty());
        //int length()：返回字符串的长度
        System.out.println("abc".length());
        //String concat(xx)：拼接，等价于+
        System.out.println("hello".concat("world"));
        //boolean equals(Object obj)：比较字符串是否相等，区分大小写
        //boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写
        System.out.println("abc".equals("ab"));
        System.out.println("abc".equalsIgnoreCase("ABC"));
        //int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小
        System.out.println("a".compareTo("b")); //-1
        System.out.println("a".compareTo("a")); //0
        System.out.println("c".compareTo("a")); //2
        //String toUpperCase()：将字符串中小写字母转为大写
        System.out.println("abc".toUpperCase());
        //String trim()：去掉字符串前后空白符
        System.out.println(" hello   world ".trim());
        //public String intern()：结果在常量池中共享
        String a2 = "abc";
        String a3 = "a";
        String a4 = (a3+"bc").intern();
        System.out.println(a4==a2);


    }

    //字符串的对象的个数
    @Test
    public void test03(){
        String a1 = "abc"; //abc 常量
        String a2 = new String("a");  // new String("a") 堆中  常量池 "a"

        //创建了几个对象  3
        // abc 常量
        // new String("a") 堆中  常量池 "a"

        String a3 = "hello"; //hello 常量
        String a4 = new String("hello");  // new String("hello") 堆中  常量池 "hello" 指向已经创建的hello
        //创建了几个对象  2

        boolean empty = "".isEmpty();
    }

    /*
    - static String copyValueOf(char[] data)： 返回指定数组中表示该字符序列的 String
    - static String copyValueOf(char[] data, int offset, int count)：返回指定数组中表示该字符序列的 String
    - static String valueOf(char[] data)  ： 返回指定数组中表示该字符序列的 String
    - static String valueOf(char[] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
    - static String valueOf(xx  value)：xx支持各种数据类型，返回各种数据类型的value参数的字符串表示形式。
     */
    @Test
    public void test02(){
        char[] arr = {'a','b','c','d'};
        String s = String.copyValueOf(arr, 0, 2);
        System.out.println(s);

        String s1 = String.valueOf(12);
        System.out.println(s1);

        String s2 = String.valueOf(arr);
        System.out.println(s2);

    }

    /*
     * `public String() ` ：初始化新创建的 String对象，以使其表示空字符序列。
     * ` String(String original)`： 初始化一个新创建的 `String` 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
     * `public String(char[] value) ` ：通过当前参数中的字符数组来构造新的String。
     * `public String(char[] value,int offset, int count) ` ：通过字符数组的一部分来构造新的String。
     * `public String(byte[] bytes) ` ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
     * `public String(byte[] bytes,String charsetName) ` ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。
     */

    @Test
    public void test01() throws UnsupportedEncodingException {
        String a1 = "abc"; //直接指向常量
        String a2 = new String("abc"); //通过堆内存指向常量池中的abc常量

        System.out.println(a1==a2);

        String a3 = new String();
        if ( a3 != null && a3.length()==0){
            System.out.println("空字符串");
        }

        //char数组
        char[] chars = {'a','b','c'};
        String a4 = new String(chars);

        System.out.println(a4);

        byte[] bytes = "中国".getBytes("GBK");
        System.out.println(Arrays.toString(bytes));

        String a5 = new String(bytes,"GBK");
        System.out.println(a5);

    }

}
