String小结

/**
* String字符串：
* 由多个字符组成的一串数据
* 字符的本质是一个字符数组
*
* 两种创建方式的存放地不同
* (方法区的)常量池：String s = "123"; 直接赋值
* 堆：String s = new String("123"); 通过构造方法(先在堆里new String，然后指向常量池里的字符串地址)
* ==:
* 基本数据类型：比较的是基本数据类型的 值 是否相同
* 引用数据类型：比较的是引用数据类型的 地址 是否相同
*
* String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列
String(String original)
初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；
换句话说，新创建的字符串是该参数字符串的副本。
*
*
* String 的判断：
* boolean equals(Object obj);比较字符串内容是否相当
* boolean equalsIgnoreCase(String anotherString) 比较字符串内容是否相等，忽略大小写
* boolean startsWith(String starts) 测试此字符串是否以指定的starts开始
* boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
*
*
* String 是一个特殊的引用数据类型，可以直接输出字符对象中的数据,String的长度不会变
* String s="1"; s+="2";是不会报错的。
* ->常量区新建"1"，s指向"1"
* ->常量区新建"2"和"12"
* ->s中断指向"1"，指向"12"
* 结论：长度不变指的是“值”的长度不变，当有新的赋值的时候，是在常量区建立新值并
* 指向新值，而旧值则是原值不变并且不被 引用 。（也就会浪费空间）
*/

/*
* String定义
*/
// String s = "asd";
// String s1 = new String("asd");//也可以new String(chs)
// String s3 = "asd";
// char[] chs = {'a','b','c','d','e','f'};
//String(char[] value,int offset,int count)
// String s2 = new String(chs,1,3);

/*
* 对比：（引用地址）
* String了"asd"的值（不管是构造方法还是直接赋值）以后，首先是在方法区的
* 常量池里新建了"asd"这个字符串。
* 如果是构造方法，那么是栈里的s1指向堆里的new String，堆里指向常量池
* 如果是直接赋值，会先寻找常量池里有没有"asd"，有就指向常量池
* ->常量池创建"asd"后，s指向"asd"
* ->s1指向堆里的new String，new String指向"asd"
* ->s3搜索常量池里有没有"asd",有，指向"asd"
*
* 如果不加括号，"s==s3"+s以后，再与s3作对比，便是false了
*/
// System.out.println("s==s1:"+(s==s1));//s==s1:false
// System.out.println("s==s3:"+s==s3);//false
// System.out.println("s==s3:"+(s==s3));//s==s3:true

---

/**
* StringBuilder：是一个可变的字符串。字符串缓冲区 类。（也就是需要先实例化）
* String和StringBulider的区别：
* String是固定的，StringBuilder是可变的。
*/

/*
* StringBuilder
*/
// StringBuilder sss = new StringBuilder("hehe ");
// System.out.println(sss.capacity());//返回sss的容量
// System.out.println(sss.length());//返回sss的实际大小
// System.out.println(sss.append(s));//在sss后加上字符串
// //链式编程
// sss.append("a").append("b").append("c");
// //逆序
// sss.reverse();

---

 

        /*
         * object和equals
         */
//        Student stu = new Student();
//        System.out.println(stu.toString());//com.inclass.study.Student@1db9742
//        System.out.println(stu);//com.inclass.study.Student@1db9742
        //说明我们输出一个对象就是默认输出这个对象的toString
/*        Object类中的源码
 *         public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        //getclass作用是获取包名
*/        
//        Student stu2 = new Student();
//        System.out.println(stu2);
//        System.out.println(stu.equals(stu2));
/*        这个时候是false
 *         public boolean equals(Object obj) {
            return (this == obj);
        }
        在Student类中重写（直接用Source里的get hashcode and equals就可以）equals后
            @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
        
        便会return true
*/

---

 

是