String类，String类中的方法

param 参数

文档注释：功能级注释，在常量、方法、类上使用

Object类：顶级父类，所有对象父类

Object下的方法：
    Object o = new Object();
    o.hashCode();  返回对象在内存中的哈希码值
    o.toString();  返回该对象在内存中的地址值
    o.equals("a");  判断两个对象是否相等

toString() 重写前是返回地址值，重写后是返回属性值
equals() 重写前 基本数据类型比较的是值本身，引用数据类型比较的是地址值
    重写后 比较的是 对象间的属性值

String类：

    String 是不可变对象，其不可以被继承，
    并且String对象一旦被创建，内容不可改变，若改变内容，则必须创建新对象
    String 内部维护一个char数组 用来保存对应的所有字符

    采用字面值的方式创建一个字符串时，JVM首先会去字符串常量池中查找是否存在该字符串
            如果不存在，则在字符串常量池中创建这个对象
            然后将这个对象的地址返回给这个对象的引用 s1；
            如果存在，则不创建任何对象，直接将常量池中的对象地址返回，赋值给新的引用 s2。
            因此，s1 和 s2 指向的是同一个字符串常量池中的对象，所以结果为 true。
            字符串常量池 字符串7以后在堆里  6以前在方法区里

    采用new关键字新建一个字符串对象时，JVM首先在字符串常量池中查找有没有 "123abc" 这个字符串对象，
       如果有，则不在池中再去创建这个对象，直接在堆中创建一个 "123abc" 字符串对象
            然后将这个对象的地址值返回给引用，这样引用就指向了堆中创建的这个 "123abc" 字符串对象；
            如果没有，则首先在字符串常量池中创建一个 "123abc" 对象，然后再去堆里创建一个 "123abc" 对象，
            再把地址赋值给引用，这样引用就指向了堆中创建的这个字符串对象

    编译器有一个特点：当编译时遇到一个计算表达式可以在编译期间确定结果时，
            编译器就会进行计算并将结果编到.class文件中。
            所以下面的代码会被编译器改为：
            String s5 = "123abc";
            因此虚拟机运行时会重用s2对象

String类下的方法：

    length()    获取当前字符串长度
    indexOf()    检索给定字符串在当前字符串中的位置
    charAt()    获取指定位置处的字符
    startsWith()    判断字符串是否是以给定的内容开始或结束的
    toUpperCase()    将字符串的英文部分转换成全大写或全小写
    substring()    截取当前字符串中指定范围内的字符串
    Trim()    去除字符串两边的空白字符
    valueOf()    将基本类型转为String类型
    concat()    将指定字符串拼接到当前字符串后面
    contains()    判断当前字符串是否包含指定字符串
    isEmpty()    判断当前字符串是否为空
    matches()    字符串支持正则表达式
    split()    字符串支持正则表达式
    replaceAll()    字符串支持正则表达式

package String;

/**
 * String类
 * String是不可变对象，其不可以被继承，并且String对象一旦创建，内容不可改变
 * 若改变内容则必须创建新对象
 * String内部维护一个char数组用来保存对应的所有字符。
 *
 * @author lion
 * @date 2021/5/19 10:41
 */
public class Test01_String {
    public static void main(String[] args) {
        /*
        采用字面值的方式创建一个字符串时，JVM首先会去字符串常量池中查找是否
        存在该字符串对象，如果不存在，则在字符串常量池中创建这个对象，然后将
        这个对象的地址返回给这个对象的引用s1；如果存在，则不创建任何对象，直接
        将常量池中的对象地址返回，赋值给新的引用s2。因此，s1和s2指向的是
        同一个字符串常量池中的对象，所以结果为true。
         */
        String s1 = "123abc";
        String s2 = "123abc";//s2重用了s1对象
        String s3 = "123abc";
        System.out.println(s1 == s2);//地址是相同的
        System.out.println(s1 == s3);

        s1 = s1 + "?";//修改内容会创建新的对象
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
        System.out.println(s1 == s2);//false 地址不同了

        /*
        采用new关键字新建一个字符串对象时，JVM首先在字符串常量池中查找有没有
        "123abc"这个字符串对象，如果有，则不在池中再去创建这个对象，直接在堆
        中创建一个"123abc"字符串对象，然后将这个对象的地址值返回给引用，这样
        引用就指向了堆中创建的这个"123abc"字符串对象；
        如果没有，则首先在字符串常量池中创建一个"123abc"对象，然后再去堆里创建
        一个"123abc"对象，再把地址赋值给引用，这样引用就指向了堆中创建的这个字符
        串对象。
         */
        String s4 = new String("123abc");//new是强制创建新对象
        System.out.println(s4);
        System.out.println(s2 == s4);//false
        //String类中重写了equals方法，比较字符串的内容
        //这也是将来比较字符串最常用的操作
        System.out.println(s2.equals(s4));

        /*
        编译器有一个特点：当编译时遇到一个计算表达式可以在编译期间确定结果时，
        编译器就会进行计算并将结果编到.class文件中。所以下面的代码会被编译器
        改为：String s5 = "123abc"; 因此虚拟机运行时会重用s2对象。
         */
        String s5 = "123"+"abc";
        System.out.println("s5:"+s5);
        System.out.println(s2 == s5);//true

        String s6 = "123";
        String s7 = s6 + "abc";//修改内容创建新对象
        System.out.println("s7:"+s7);
        System.out.println(s2 == s7);//false

    }
}

package String;

/**
 * int length()
 * 获取当前字符串的长度(字符个数)
 *
 * @author lion
 * @date 2021/5/19 14:03
 */
public class Test02_Length {
    public static void main(String[] args) {
        String str = "你好java!!";
        System.out.println(str.length());
        //数组有没有length方法？String有没有length属性？
        //没有，数组中是length属性，字符串中是length方法。
    }
}

package String;

/**
 * int indexOf(String str)
 * 检索给定字符串在当前字符串中的位置，如果当前字符串不包含该内容则返回值为-1
 * @author lion
 * @date 2021/5/19 14:10
 */
public class Test03_IndexOf {
    public static void main(String[] args) {
        //            0123456789012345
        String str = "Thinking in Java";
        int index = str.indexOf("in");
        System.out.println(index);//2
        //从指定位置开始查找第一次出现指定字符串的位置
        int index2 = str.indexOf("in",index+1);
        System.out.println(index2);//5
        //查找最后一次出现指定字符的位置
        int index3 = str.lastIndexOf("in");
        System.out.println(index3);//9
        //当检索的内容在当前字符串中不存在时返回值为-1
        int index4 = str.indexOf("t");
        System.out.println(index4);//-1

        //可以用于检索是否包含内容，判断是否有重复信息

        //当参数为int类型时，查找数字在unicode编码中对应的字符所在的位置
        System.out.println(str.indexOf(97));//97--a,index--13
    }
}

package String;

/**
 * char charAt(int index)
 * 获取指定位置处的字符
 *
 * @author lion
 * @date 2021/5/19 14:40
 */
public class Test04_CharAt {
    public static void main(String[] args) {
        //            0123456789
        String str = "HelloWorld";
        char c = str.charAt(5);
        System.out.println(c);
        //回文
        //             0 1 2 3 4 5 6
        String line = "雾了山头了锁雾";
        for (int i = 0; i < line.length()/2; i++) {
            char c1 = line.charAt(i);
            char c2 = line.charAt(line.length()-1-i);
            if(c1 != c2){
                System.out.print("不");
                break;
            }
        }
        System.out.println("是回文");

    }
}

package String;

/**
 * boolean startsWith(String str)
 * boolean endsWith(String str)
 * 判断字符串是否是以给定的内容开始或结束的
 * @author lion
 * @date 2021/5/19 15:19
 */
public class Test05_StartsWith {
    public static void main(String[] args) {
        String str = "www.huacit.com";

        boolean starts = str.startsWith("www.");
        System.out.println("starts:"+starts);

        boolean ends = str.endsWith(".com");
        System.out.println("ends:"+ends);
    }
}

package String;

/**
 * String toUpperCase()
 * String toLowerCase()
 * 将字符串中的英文部分转换为全大写或全小写
 * @author lion
 * @date 2021/5/19 15:26
 */
public class Test06_ToUpperCase {
    public static void main(String[] args) {
        String str = "我爱Java";

        String upper = str.toUpperCase();
        System.out.println(upper);

        String lower = str.toLowerCase();
        System.out.println(lower);
    }
}

package String;

/**
 * String subString(int start,int end)
 * 截取当前字符串中指定范围内的字符串
 * 注意：java API中通常使用两个数字表示范围时是"含头不含尾"的
 * @author lion
 * @date 2021/5/19 15:34
 */
public class Test07_SubString {
    public static void main(String[] args) {
        //            01234567890123
        String str = "www.huacit.com";
        String sub = str.substring(4,10);
        System.out.println(sub);
        //一个参数的重载方法是从指定位置一直截取到字符串末尾
        sub = str.substring(4);
        System.out.println(sub);


    }
}

package String;

/**
 * String trim()
 * 去除字符串两边的空白字符
 * @author lion
 * @date 2021/5/19 15:43
 */
public class Test08_Trim {
    public static void main(String[] args) {
        String str = "   he llo      ";
        System.out.println(str);
        String trim = str.trim();
        System.out.println(trim);
    }
}

package String;

/**
 * String提供了一组静态方法：valueOf
 * 作用是一致的，将其他类型转换为String
 * 常用于将基本类型转为String类型
 * @author lion
 * @date 2021/5/19 15:47
 */
public class Test09_ValueOf {
    public static void main(String[] args) {
        int a = 123;
        String s1 = String.valueOf(a);//"123"
        System.out.println(s1);

        double b = 123.123;
        String s2 = String.valueOf(b);//"123.123"
        System.out.println(s2);

        s1 = a + "";
        System.out.println(s1);

    }
}

package String;

/**
 * String concat(String str)
 * @author lion
 * @date 2021/5/19 15:54
 */
public class Test10_Concat {
    public static void main(String[] args) {
        String str = "123";
        String s = str.concat("abc");
        System.out.println(s);

        str = "123";
        s = str + "abc";
        System.out.println(s);
    }
}

package String;

/**
 * boolean contains(String str)
 * 判断当前字符串是否包含指定字符串
 * @author lion
 * @date 2021/5/19 16:20
 */
public class Test11_Contains {
    public static void main(String[] args) {
        String str = "abc";
        boolean b = str.contains("a");
        System.out.println(b);
    }
}

package String;

/**
 * boolean isEmpty()
 * 判断当前字符串内容是否为空
 * @author lion
 * @date 2021/5/19 16:23
 */
public class Test12_IsEmpty {
//    static String str;
    public static void main(String[] args) {
//        System.out.println(str);//null
        String str = null;
        //使用空引用调用属性或方法会出现空指针异常
//        boolean b = str.isEmpty();//java.lang.NullPointerException
//        System.out.println(b);
        str = "123";
        boolean b = str.isEmpty();
        System.out.println(b);
    }
}

package String;

/**
 * 字符串支持正则表达式的方法一：
 * boolean matches(String regex)
 * 使用给定的正则表达式验证当前字符串的格式，匹配则返回true
 *
 * @author lion
 * @date 2021/5/19 16:33
 */
public class Test13_Matches {
    public static void main(String[] args) {
        String email = "wangmm@huacit.cn";
        /*
        email的正则表达式
        [a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-z]+)+
         */
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-z]+)+";
        boolean b = email.matches(regex);
        System.out.println(b);
        if(b){
            System.out.println("邮箱格式正确！");
        }else{
            System.out.println("邮箱格式有误！");
        }
    }
}

package String;

import java.util.Arrays;

/**
 * String支持正则表达式的方法二：
 * String[] split(String regex)
 * 将当前字符串按照满足正则表达式的部分进行拆分，并将拆分后的各部分以一个字符串数组
 * 的形式返回。
 * @author lion
 * @date 2021/5/19 17:20
 */
public class Test14_Split {
    public static void main(String[] args) {
        String str = "abc123def456ghi";
        String[] arr = str.split("[0-9]+");
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));

        /*
        split()如果连续遇到两个可拆分项，中间会拆分出一个空字符串。
        在字符串开始就遇到时，那么第一项会拆分出空字符串，
        但是在字符串末尾连续遇到可拆分项，会忽略所有拆分出来的空字符串。
         */
        str = ",abc,,def,ghi,,,,,,,,";
        arr = str.split(",");
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
    }
}

package String;

/**
 * 字符串支持正则表达式的方法三：
 * String replaceAll(String regex,String str)
 * 将当前字符串中满足正则表达式的部分替换为给定的内容
 * @author lion
 * @date 2021/5/19 17:38
 */
public class Test15_ReplaceAll {
    public static void main(String[] args) {
        String str = "abc123def456ghi";
        //将数字替换为 #
        str = str.replaceAll("[0-9]+","#");
        System.out.println(str);

        String regex = "(mdzz|nt|sb|wdnmd)";
        String message = "mdzz,你是sb吧！wdnmd";
        message = message.replaceAll(regex,"***");
        System.out.println(message);
    }
}