• 【零基础学Java】第十八篇 包装类1（Integer,String)

    📄个人简介
    🔔作者简介：大家好，我是小学生！！🙈大三学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
    📝个人主页：小学生！！
    📖系列专栏
    🌕阶段一：Java基础编程
    💦目前已原创18篇

    🌕阶段二：数据结构与算法
    🌕阶段三：操作系统
    🌕阶段四：计算机网络

    文章目录

    🔥本节主要介绍了包装类的种类，Integer和String类型的用法。

    1.包装类的分类

    基本数据类型包装类
    booleanBoolean
    charCharacter
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uVIBuatO-1660368308172)(C:\Users\w'y'x\AppData\Roaming\Typora\typora-user-images\image-20220812094233170.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckiUH5zf-1660367180347)(C:\Users\w'y'x\AppData\Roaming\Typora\typora-user-images\image-20220812094323844.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dtYaoLdc-1660367180347)(C:\Users\w'y'x\AppData\Roaming\Typora\typora-user-images\image-20220812094411645.png)]

    2.包装类Integer与String类型的转换

    //包装类型-->String类型
Integer i = 10;
//方式1:
String s1 = i.toString();
//方式2:
String s2 = String.valueOf(0);
//方式3:
String s3 = i +"";
System.out.println(s3);
//String—>包装类
//方式1:
Integer j = new Integer(s1);
//方式2:
Integer j2 = Integer.valueOf(s2);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    3.Integer类面试题总结

    public class WrapperExercise01 {
    public static void main(String[] args) {
        Double d = 100d; //ok, 自动装箱 Double.valueOf(100d);
        Float f = 1.5f; //ok, 自动装箱 Float.valueOf(1.5f);

        Object obj1 = true? new Integer(1) : new Double(2.0);//三元运算符是一个整体,格式精确度更高的保持一致
        System.out.println(obj1);//  1.0

        Object obj2;
        if(true)
            obj2 = new Integer(1);
        else
            obj2 = new Double(2.0);
        System.out.println(obj2);//1
        

    }
}
public class WrapperExercise02 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);  //False
       /*
        //1. 如果i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
        //2. 如果不在 -128~127,就直接 new Integer(i)
         public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
         */
        Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
        Integer n = 1;//底层 Integer.valueOf(1);
        System.out.println(m == n); //T
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        //，否则，就new Integer(xx);
        Integer x = 128;//底层Integer.valueOf(1);
        Integer y = 128;//底层Integer.valueOf(1);
        System.out.println(x == y);//False

    }
}
public class WrapperExercise03 {
    public static void main(String[] args) {
        //示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F
        //示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F 
        //示例三
        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);
        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


    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

    4.String类的结构剖析

    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不能指向新的地址，但是单个字符内容是可以变化

    public class String01 {
    public static void main(String[] args) { 
        String name = "jack";
        name = "tom";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';
        //value = v2; 不可以修改 value地址
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5.两种创建String对象的区别

    方式一：直接赋值String s = “hsp”;

    方式二：调用构造器String s2 = new String(“hsp”);

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

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

    public class StringExercise01 {
    public static void main(String[] args) {
        String a = "abc";
        String b ="abc";
        //String重写了equals方法比较值是否相同
        System.out.println(a.equals(b));//T
        //比较是否是同一个对象
        System.out.println(a==b); //T
    }
}
public class StringExercise02 {
    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 
        System.out.println(b==b.intern()); //F
       /*当调用intern方法时，如果池已经包含一个等于此String对家的子付串用equals(Object)方法确定),
       则返回池中的字符串。否则,将此 String对象添加到池中，并返回此 String对象的引用。
       */
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    6.String对象的特性

    1. String类是一个final类型的，代表不可变字符序列。
    2. 一个字符串对象被一旦分配，其内容是不可变的。
    public class StringExercise03 {
    public static void main(String[] args) {
        String a = "hello"; //创建 hello对象
        a="haha";//创建haha对象
        String b = "abc";//创建 abc对象
        //1. 先 创建一个 StringBuilder sb = StringBuilder()
        //2. 执行  sb.append("hello");
        //3. sb.append("abc");
        //4. String c= sb.toString()
        //最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc"
        String c = a + b;//变量相加，看堆
        String d = "helloabc";
        System.out.println(c == d);//false
        String e = "hello" + "abc";//常量相加，直接看池， e指向常量池，若没有只创建一个对象helloabc
        System.out.println(d == e);//true
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    7.String类的常见方法

    1. equals ：区分大小写,判断内容是否相等。
    2. equalslgnoreCase：忽略大小写的判断内容是否相等。
    3. length：获取字符的个数,字符串的长度。
    4. indexOf：获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1。
    5. lastIndexOf：获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1。
    6. substring ：截取指定范围的子串。
    7. trim：去前后空格。
    8. charAt：获取某索引处的字符,注意不能使用Str[index]这种方式。
    9. toUpperCase：将字符转换成大写。
    10. toLowerCase：将字符转换成小写。
    11. concat：拼接字符串。
    12. replace：替换字符串中的字符。
    13. split ：分割字符串,对于某些分割字符，我们需要转义比如|,\\等。
    14. compareTo ：比较两个字符串的大小。
    15. toCharArray ：转换成字符数组。
    16. format ：格式字符串,%s字符串%c字符%d整型%.2f 浮点型。
    public class StringMethod01 {
    public static void main(String[] args) {
        //1. equals 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));
        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }
        // 3.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());
        // 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"));//0
        // 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

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    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);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
  • 相关阅读:
    「高效程序员的修炼」代码版本管理工具 Git 用起来 01 Git 基础
    修改安卓ID为硬件唯一ID
    超级细胞丨爆款游戏公司Supercell组织敏捷化是如何实现的
    Java——面向对象初阶
    Node.js——http模块和导出共享
    联表查询JoinON详解（自连接）
    D. Anti-Sudoku
    Git学习
    dvc使用方法
    【CSS动效实战（纯CSS与JS动效）】03 精美手风琴侧边栏完整示例教程 示例1
  • 原文地址：https://blog.csdn.net/m0_54024106/article/details/126318545