java

1.String类在java.lang中

2.实现了3个接口：Serializable，CharSequence，Comparable

3.创建：

String s = "aaa";

String s = new String();

String s = new String("aaa");

String s = newString(byte[] b);   -----> 数字换成char然后拼起来

String s = newString(char[] b); 

4.String的不可变特性：

长度和内容不可变，引用数组不可变。

package stringtest;

public class StringTest {
    public static void main(String[] args){
        String s1 = "aaa";
        String a = s1;
        s1 = "bbb";//String每次赋值其实是新new了一个对象，因为本身本质是final char[]所以长度和内容不能改变。
        String b = s1;
        System.out.println(a == b);

        TestClass tc1 = new TestClass();
        tc1.s = "aaa";
        TestClass c = tc1;
        tc1.s = "bbb";//一般的引用类变量则是堆内存空间指针，所以内容改变了本身地址并不会变。
        TestClass d = tc1;
        System.out.println(c == d);

    }
}

5.String类中的常用方法

package stringtest;

public class StringTest {
    public static void main(String[] args){
        String s1 = "aaa";
        String a = s1;
        s1 = "bbb";//String每次赋值其实是新new了一个对象，因为本身本质是final char[]所以长度和内容不能改变。
        String b = s1;
        System.out.println("a == b" + (a == b));

        TestClass tc1 = new TestClass();
        tc1.s = "aaa";
        TestClass c = tc1;
        tc1.s = "bbb";//一般的引用类变量则是堆内存空间指针，所以内容改变了本身地址并不会变。
        TestClass d = tc1;
        System.out.println("c == d" + (c == d));

        //常用方法
        //equals
        String s2 = new String("abc");
        String s3 = new String(new char[]{'a','b','c'});
        System.out.println("s2 == s3" + (s2 == s3));
        System.out.println("s2.equals(s3)" + s2.equals(s3)); // 不管地址或者声明方法是否一样，只比较String存储的char[]的值
        //hashcode
//        public static int hashCode(byte[] value) {
//            int h = 0;
//            for (byte v : value) {
//                h = 31 * h + (v & 0xff);
//            }
//            return h;
//        }
        //把String中每一个字符遍历，每次让h = 31 * h + 字符的字符码
        System.out.println("a".hashCode());
        System.out.println((int)('a'));//把char a强制转换为int可以知道它的字符码
        //a的字符码为97，所以结果为97
        System.out.println("ab".hashCode());
        //a的字符码为97，b的字符码为98，
        // 第一次循环h = 31 * 0 + 97 = 97
        // 第二次循环h = 31 * 97 + 98  = 3105
        System.out.println(31 * 97 + 98);

        //compareTo
        //先找寻比较的字符串中较短的那个作为比较循环的次数，然后比较，
        System.out.println("abc".compareTo("abe")); //比较Char1[i] - Char2[i]，c - e = -2
        System.out.println("abcde".compareTo("ab")); //如果两个字符串长度不同，但是前半部分一样，则比较长度  5 - 2 = 3
        System.out.println("abde".compareTo("abc"));// d - c = 1

        //toString
        TestClass testToString = new TestClass();
        System.out.println(testToString.toString()); //一般引用类的toString = 类名@hashcode
        int i = testToString.hashCode();
        System.out.println(Integer.toHexString(i));//转化为16进制
        //也可以用这个方法，后面参数是进制： System.out.println(Integer.toString(i,16));

        String sToString = "a";
        System.out.println(sToString.toString());//String的toString重写过，结果为char[]的值

        //charAt
        System.out.println("abc".charAt(2));//返回char[2]的值

        //length
        System.out.println("abc".length());//返回char[]长度
        System.out.println(new char[]{'a','b','c'}.length);//注意和char[]的区别，数组的length是属性，String的是方法

        //concat
        System.out.println("a".concat("bc"));//拼接“a”和“bc”，返回一个Stirng类型，与+效果相同，性能concat更好。
        // 如果频繁拼接，最好使用StringBuilder（效率高）或者StringBuffer（更安全，适合多线程）
        StringBuffer sb1 = new StringBuffer("a");
        StringBuffer sb2 = new StringBuffer("bc");
        StringBuffer sb3 = sb1;
        sb1 = sb1.append(sb2);//append()用来拼接sb1 和 sb2
        StringBuffer sb4 = sb1;
        System.out.println(sb3 == sb4); //如果是string的话，之前测试过会返回false，因为String不可变性，会让它每次改变时生成新的对象，而StringBuffer则是原基础拼接，所以效率更高。

        //toLowerCase
        System.out.println("ABc".toLowerCase());//全部变成小写，常用来做比较

        //codePointAt
        System.out.println("ABc".codePointAt(0));//返回char[2]的字符码值，A是65，a是97

        //substring
        System.out.println("ABc".substring(1,2));//char[1] - char[2] 的截取
        System.out.println("ABc".substring(1)); //从char[1]截取到最后

        //split
        String[] sArr = "aaadbcd//dedfd".split("d"); //以d为分界线，分割string并返回分割后的数组
        System.out.println(sArr.length);
        for(int j = 0 ; j < sArr.length; j++){
            System.out.println("sArr中的第" + j + "个值=" + sArr[j] + "!!!");
        }
//        5
//        sArr中的第0个值=aaa!!!
//        sArr中的第1个值=bc!!!
//        sArr中的第2个值=//!!!
//        sArr中的第3个值=e!!!
//        sArr中的第4个值=f!!!
        //结尾d后面并没有切割出""

        sArr = "aaadbcd//dedfd".split("/"); //以d为分界线，分割string并返回分割后的数组
        System.out.println(sArr.length);
        for(int j = 0 ; j < sArr.length; j++){
            System.out.println("sArr中的第" + j + "个值=" + sArr[j] + "!!!");
        }
//        3
//        sArr中的第0个值=aaadbcd!!!
//        sArr中的第1个值=!!!     //中间两个//之间的""被切割了出来
//        sArr中的第2个值=dedfd!!!

        sArr = "aaadbcd\dedfd".split("\\"); //以d为分界线，分割string并返回分割后的数组 两个\表示转义，String中是特殊字符，不能存在。|也是特殊字符，需要用\|来表示
        System.out.println(sArr.length);
        for(int j = 0 ; j < sArr.length; j++){
            System.out.println("sArr中的第" + j + "个值=" + sArr[j] + "!!!");
        }
//        2
//        sArr中的第0个值=aaadbcd!!!
//        sArr中的第1个值=dedfd!!!

        sArr = "aaadbcd|dedfd".split("\|"); //以d为分界线，分割string并返回分割后的数组 两个\表示转义，String中是特殊字符，不能存在。|也是特殊字符，需要用\|来表示
        System.out.println(sArr.length);
        for(int j = 0 ; j < sArr.length; j++){
            System.out.println("sArr中的第" + j + "个值=" + sArr[j] + "!!!");
        }
//        2
//        sArr中的第0个值=aaadbcd!!!
//        sArr中的第1个值=dedfd!!!

        //replace
        System.out.println("abcba".replace("b","abc"));//replace(old,new)替换
        //aabccabca

    }
}