包装类，String，String的方法

关系图

拆箱，装箱

package com.jshedu.wrapper;

/**
 * @author Mr.jia
 * @version 1.0
 */

public class Wrapper01 {
    public static void main(String[] args) {
        //演示int<---->Integer的装箱和拆箱
        //jdk5前是手动装箱，和拆箱
        //手动装箱int--->Integer,基本数据类型转换成包装类。
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);

        //手动拆箱
        //Integer--->int
        int i = integer.intValue();

        //jdk5以后就可以自动装箱，自动拆箱
        int n2 = 200;
        //自动装箱int-->Integer
        Integer integer2 = n2;//底层Integer.valueOf(n2)
        //自动拆箱Integer--->int
        int n3 = integer2;//底层intValue()方法

    }


}

注意底层处理

 三元运算符是一个整体，最后的结果的数据类型是里面最大的数据类型

package com.jshedu.wrapper;

/**
 * @author Mr.jia
 * @version 1.0
 */

public class Wrapper02 {
    public static void main(String[] args) {
        //包装类(Integer)-->String
        Integer i = 100;//自动装箱
        //方式一
        String str = i+"";
        //方拾二
        String str2 = i.toString();
        //方式3
        String str3 = String.valueOf(i);
        
        //String -->包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器
        
    }
}

Integer--->String,String --->Integer

面试题

 注意只要有基本数据类型 判断的是值是否相同。

String类的理解和创建对象

1. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节

2. String类有很多构造器

3. String类实现了Serializable接口【String可以串行化，可以在网络传输】

4. String类实现了Comparable接口【String对象可以比较大小】

5. String是final类，不能被其它类继承

6. String 有属性private final char value[];用于存放字符串内容，本质就是一个char数组把一个一个字符存进去，

7. 一定注意：value是一个final类型，不可修改（value地址不可修改不能指向新的地址，但是单个字符内容是可以变化的）

两种创建String对象的区别

1. 方式一：先从常量池看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址

2. 方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址。

3. 

    String类的intern（）返回常量池的地址

4. 例题

    常量池里面不能有两个一样的字符串

5. 创建了2个对象，并不是把原先的hello给更改成为haha，而是新创建了haha，然后s1的地址变化指向haha

6. 底层做了优化

7. 常量相加看池，变量相加看堆

    

   package com.jshedu.String_;
   
   /**
    * @author Mr.jia
    * @version 1.0
    */
   
   public class Excecise01 {
       public static void main(String[] args) {
           String a = "hello";
           String b = "abc";
           /*
           * 1.先 创建一个StringBuilder sb = new StringBuilder()
           * 2.执行 sb.append("hello");
           * 3.再次sb.append("abc");
           * 4.String c = sb.toString();
           * 最后其实是c指向堆中的对象(String)value[]->池中"helloabc"
           * */
           String c= a+b;//这个c指向堆中的value数组
           String d = "helloabc";
           System.out.println(c==d);//false
       }
   }
   

   

String类的常见方法：String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低。

1. package com.jshedu.String_;
   
   /**
    * @author jia
    * @version 1.0
    */
   public class StringMethod01 {
       public static void main(String[] args) {
           //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
           String str1 = "hello";
           String str2 = "Hello";
           System.out.println(str1.equals(str2));//false
   
           // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
           String username = "johN";
           if ("john".equalsIgnoreCase(username)) {
               System.out.println("Success!");//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("we"));//weIndex=0
           // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
           s1 = "wer@terwe@g@";
           index = s1.lastIndexOf('@');
           System.out.println(index);//11
           System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//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
   
       }
   }
   /*
   false
   Success!
   3
   3
   weIndex=0
   11
   ter的位置=4
   张三
   llo*/
   

   常见方法

2. package com.jshedu.String_;
   
   /**
    * @author jia
    * @version 1.0
    */
   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 林黛玉 林黛玉 林黛玉";
           //在s1中，将 所有的 林黛玉 替换成薛宝钗
           // 老韩解读: s1.replace() 方法执行后，返回的结果才是替换过的.
           // 注意对 s1没有任何影响
           String s11 = s1.replace("宝玉", "jack");
           System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
           System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
           // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
           String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
           //老韩解读：
           // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
           // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
           String[] split = poem.split(",");
           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 转换成字符数组
           s = "happy";
           char[] chs = s.toCharArray();
           for (int i = 0; i < chs.length; i++) {
               System.out.println(chs[i]);
           }
           // 7.compareTo 比较两个字符串的大小，如果前者大，
           // 则返回正数，后者大，则返回负数，如果相等，返回0
           // 老韩解读
           // (1) 如果长度相同，并且每个字符也相同，就返回 0
           // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
           //     就返回 if (c1 != c2) {
           //                return c1 - c2;
           //            }
           // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
           String a = "jcck";// len = 3
           String b = "jack";// len = 4
           System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值
   // 8.format 格式字符串
           /* 占位符有:
            * %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 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
           //6. %c 使用char 类型来替换
           String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
   
           String info2 = String.format(formatStr, name, age, score, gender);
   
           System.out.println("info2=" + info2);
       }
   }