package com.stulzl.wrapper_exercise02;

//包装类 经典面试题02  464
public class Exercise02 {
    public static void main(String[] args) {
        //示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F//new得对象

        //示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F//new得对象

        //示例三
        Integer i5 = 127;//底层 Integer.valueOf(127)
        Integer i6 = 127;//-128~127
        System.out.println(i5 == i6); //T//在范围内

        //示例四
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//F//不在范围内

        //示例五
        Integer i9 = 127; //Integer.valueOf(127)//在范围内
        Integer i10 = new Integer(127);//new的
        System.out.println(i9 == i10);//F

        //示例六
        Integer i11=127;//在范围内
        int i12=127;// 只有 有基本数据类型，==判断的是值是否相同
        System.out.println(i11==i12); //T

        //示例七
        Integer i13=128;//在范围内
        int i14=128;//只有 有基本数据类型，==判断的是值是否相同
        System.out.println(i13==i14);//T
    }
}

package com.stulzl.string_;

//String类465
public class String01 {
    public static void main(String[] args) {
        //1.String 对象用于保存字符串，也就是一组字符序列
        //2. "jack" 字符串常量, 双引号括起的字符序列
        //3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
        //4. String 类有很多构造器，构造器的重载
        // 常用的有 String s1 = new String(); //
        //String s2 = new String(String original);
        //String s3 = new String(char[] a);
        //String s4 = new String(char[] a,int startIndex,int count)
        //String s5 = new String(byte[] b)
        //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
        // 接口 Comparable [String 对象可以比较大小]
        //6. String 是 final 类，不能被其他的类继承
        //7. String 有属性 private final char value[]; 用于存放字符串内容
        //8. 一定要注意：value 是一个 final 类型， 不可以修改：即 value 不能指向
        // 新的地址，但是单个字符内容值是可以变化的
        String name = "jack";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';//但是值可以修改
        //value = v2; //不可以修改 value 地址,因为是final修饰的
    }
}

package com.stulzl.string_exercise01;

//String练习466
public class Exercise01 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));//t
        System.out.println(a==b);//t//a  b指向同一对象
    }
}

package com.stulzl.string_exercise02;

public class Exercise02 {
    public static void main(String[] args) {
        String a = "hsp"; //a 指向 常量池的 “hsp”
        String b =new String("hsp");//b 指向堆中对象
        System.out.println(a.equals(b)); //T//值相等
        System.out.println(a==b); //F//对象(也就是地址)不同
        //b.intern() 方法返回常量池地址
        System.out.println(a==b.intern()); //T //b.intern()返回常量池地址，a也指向常量池地址
        System.out.println(b==b.intern()); //F //这个b指向堆中对象
    }
}

package com.stulzl.string_exercise03;

//练习3 判断输出  467
public class Exercise03 {
    public static void main(String[] args) {
        String s1 = "hspedu"; //指向常量池”hspedu”
        String s2 = "java"; //指向常量池”java”
        String s4 = "java";//指向常量池”java”
        String s3 = new String("java");//指向堆中对象
        System.out.println(s2 == s3); // F
        System.out.println(s2 == s4);  //T
        System.out.println(s2.equals(s3));//T
        System.out.println(s1 == s2);  //F
    }
}

package com.stulzl.string_exercise04;

//练习4 判断输出 468
public class Exercise04 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "hspedu";
        Person p2 = new Person();
        p2.name = "hspedu";


        System.out.println(p1.name.equals(p2.name));//比较内容: True
        //p1.name 和 p2.name都指向常量池"hspedu"的地址
        System.out.println(p1.name == p2.name);  //T
        //p1.name指向常量池中"hspedu"地址，而"hspedu"就在常量池中为同一对象
        System.out.println(p1.name == "hspedu");  //T

        String s1 = new String("bcde");
        String s2 = new String("bcde");
        System.out.println(s1==s2); //False
    }
}
class Person {
    public String name;
}

package com.stulzl.string_exercise05;

//练习5 判断输出 469
public class Exercise05 {
    public static void main(String[] args) {
        String a = "hello"; //创建 a对象
        String b = "abc";//创建 b对象
        
        //总结，就是将hello和abc合成一个helloabc放在常量池中，然后堆中有
        // 一个value指向常量池中的helloabc，最后c在指向堆中的value
        String c = a + b;
        //解读
        //1. 先 创建一个 StringBuilder sb = StringBuilder()
        //2. 执行  sb.append("hello");
        //3. sb.append("abc");
        //4. String c= sb.toString()
        //最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc"

        String d = "helloabc";
        System.out.println(c == d);//真还是假? 是false
        String e = "hello" + "abc";//直接看池， e指向常量池
        System.out.println(d == e);//真还是假? 是true
    }
}

package com.stulzl.string_exercise06;

//String练习6 判断输出470
public class Exercise06 {
    public static void main(String[] args) {
        String s1 = "hspedu";  //s1 指向池中的 “hspedu”
        String s2 = "java"; // s2 指向池中的 “java”
        String s5 = "hspedujava"; //s5 指向池中的 “hspedujava”
        String s6 = (s1 + s2).intern();//s6 指向池中的   “hspedujava”
        System.out.println(s5 == s6); //T
        System.out.println(s5.equals(s6));//T
    }
}

package com.stulzl.string_exercise07;

//String练习7 判断输出470
public class Exercise07 {
    public static void main(String[] args) {

    }
}
class Test1 {
    String str = new String("hsp");//在常量池中hsp，堆中有value指向常量池hsp
    final char[] ch = {'j', 'a', 'v', 'a'};//在堆中//数组默认放在堆中

    public void change(String str, char ch[]) {
        str = "java";//调用方法产生的新栈，这个str会在常量池中创建一个java
        ch[0] = 'h';//修改堆中的数组ch第一个元素为h
    }

    public static void main(String[] args) {
        Test1 ex = new Test1();
        ex.change(ex.str, ex.ch);//调用方法就会产生一个新栈
        System.out.print(ex.str + " and ");//hsp and //因为方法中新创建的str和他没关系
        System.out.println(ex.ch);//hava
    }
}

package com.stulzl.string_method;

//String常用的方法01 471
public class StringMethod01 {
    public static void main(String[] args) {
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//f

        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }

        // 3.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());//3

        // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("er"));//1//也可以多字符

        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4

        // 6.substring 截取指定范围的子串
        String name = "hello,张三";
        //下面name.substring(6) 从索引6开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
        //name.substring(0,5)表示从索引0开始截取，截取到索引 5-1=4位置
        System.out.println(name.substring(2,5));//llo,截取到第5-1=4个
    }
}

package com.stulzl.string_method;

//String常用的方法02 472-473
public class StringMethod02 {
    public static void main(String[] args) {

        // 1.toUpperCase转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO

        // 2.toLowerCase
        System.out.println(s.toLowerCase());//hello

        // 3.concat拼接字符串
        String s1 = "宝玉";
        s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
        System.out.println(s1);//宝玉林黛玉薛宝钗together

        // 4.replace 替换字符串中的字符
        s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
        String s5 = s1.replace("林黛玉", "薛宝钗");//在s1中，将 所有的 林黛玉 替换成薛宝钗
        System.out.println(s5);//宝玉 and 薛宝钗 薛宝钗 薛宝钗
        // 解读: s1.replace() 方法执行后，返回的结果才是替换过的.
        // 注意对 s1没有任何影响

        String s11 = s1.replace("宝玉", "jack");//在s1中，将 所有的 宝玉 替换成jack
        System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
        System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉

        // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        String[] split = poem.split(",");
        //解读：
        // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        // 6.toCharArray 转换成字符数组
        String s4 = "happy";
        char[] chs = s4.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }

        // 7.compareTo 比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回0
        // 解读
        //如果长度相同，但是个别内容不同，就直接相减(结果为 正数 或 负数)
        //如果长度不同，但是前边内容相同，就是长度相减
        //如果长度不同前边内容也不相同，就按照内容相减
        String a = "jcck";
        String b = "jack";
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值

        // 8.format 格式字符串  473
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型
         *
         */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        //将所有的信息都拼接在一个字符串.普通方法
        String info =
                "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！";

        System.out.println(info);

        //解读
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，因为.2f只会保留小数点两位, 并且进行四舍五入的处理
        //6. %c 使用char 类型来替换
        String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";

        String info2 = String.format(formatStr, name, age, score, gender);

        System.out.println("info2=" + info2);
    }
}