Java面向对象之包装类和String 类

最新推荐文章于 2024-04-22 13:09:32 发布

一切随心走_水瓶

最新推荐文章于 2024-04-22 13:09:32 发布

阅读量543

点赞数 2

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/wcg920212/article/details/121755638

版权

java 专栏收录该内容

54 篇文章 2 订阅

订阅专栏

文章目录

- - 1、常用类

1、常用类

1.1、包装类

1.1.1、包装类的分类

针对八种基本数据类型相应的引用类型—包装类
有了类的特点，就可以调用类中的方法

在这里插入图片描述

1.1.2、包装类和基本数据的转换

在这里插入图片描述

package Integer01;

public class Integer01 {
    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()方法
    }
}

1.1.3、包装类型和 String 类型的相互转换

package Integer01;

public class WrapperVSString {
    public static void main(String[] args) {
        // 包装类(Integer) -> String
        Integer i = 100;  // 自动装箱
        // 方式一
        String str1 = i + "";
        // 方式二
        String str2 = i.toString();
        // 方式三
        String str3 = String.valueOf(i);

        // String -> 包装类(Integer)
        String str4 = "12345";
        // 方式一
        Integer i2 = Integer.parseInt(str4);  // 使用到自动装箱
        // 方式二
        Integer i3 = new Integer(str4);  // 构造器
    }
}

1.1.4、Integer 类和 Character 类的常用方法

package Integer01;

public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);  // 返回最小值
        System.out.println(Integer.MAX_VALUE);  // 返回最大值
        System.out.println(Character.isDigit('a'));  // 判断是不是数字
        System.out.println(Character.isLetter('a'));  // 判断是不是字母
        System.out.println(Character.isUpperCase('a'));  // 判断是不是大写
        System.out.println(Character.isLowerCase('a'));  // 判断是不是小写
        System.out.println(Character.isWhitespace('a'));  // 判断是不是空格
        System.out.println(Character.toUpperCase('a'));  // 转成大写
        System.out.println(Character.toLowerCase('A'));  // 转成小写
    }
}

1.1.5、小练习

package Integer01;

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

        // 这里主要是看范围 -128 ~ 127 就是直接返回
        /*
        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);
        // 所以这里主要是看范围 -128 ~ 127 就是直接返回
        // 否则就 new Integer(xx);
        Integer x = 128;  // 底层 Integer.valueOf(1);
        Integer y = 128;  // 底层 Integer.valueOf(1);
        System.out.println(x == y);  // False
    }
}

1.1.6、Integer 类面试题总结

package Integer01;

public class WrapperExercise03 {
    public static void main(String[] args) {
        // 示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);  // false
        // 示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);  // false
        // 示例三
        Integer i5 = 127;  // 底层 Integer.valueOf(127)
        Integer i6 = 127;  // -128~127
        System.out.println(i5 == i6); // true
        // 示例四
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);  // false
        // 示例五
        Integer i9 = 127;  // Integer.valueOf(127)
        Integer i10 = new Integer(127);
        System.out.println(i9 == i10);  // false
        // 示例六
        Integer i11 = 127;
        int i12 = 127;
        // 只有有基本数据类型, 判断的是值是否相同
        System.out.println(i11 == i12);  // true
        // 示例七
        Integer i13 = 128;
        int i14 = 128;
        System.out.println(i13 == i14);  // true
    }
}

1.2、String 类

1.2.1、String 类的理解和创建对象

在这里插入图片描述

package Integer01;

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";
        name = "tom";
        final char[] value = {'a', 'b', 'c'};
        char[] v2 = {'t', 'o', 'm'};
        value[0] = 'H';
        // value = v2; 不可以修改 value 地址
    }
}

1.2.2、创建 String 对象的两种方式

方式一：直接赋值 String s = “zhangsan”;
方式二：调用构造器 String s = new String(“zhangsan”);

1.2.3、两种创建 String 对象的区别

1、方式一：先从常量池查看是否有“zhangsan” 数据空间，如果有，直接指向；如果没有则重新创建，然后指向，s最终指向的是常量池的空间地址
2、方式二：先在堆中创建空间，里面维护了value属性，指向常量池的zhangsan空间，如果常量池没有"zhangsan"，重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址

在这里插入图片描述

1.2.4、小练习

package stringdemo;

public class StringDemo {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));  // true
        System.out.println(a == b);  // true
    }
}

在这里插入图片描述

package stringdemo;

public class StringDemo2 {
    public static void main(String[] args) {
        String a = new String("abc");
        String b = new String("abc");
        System.out.println(a.equals(b));  // true
        System.out.println(a == b);  // false
    }
}

package stringdemo;

public class StringDemo3 {
    public static void main(String[] args) {
        String a = "zhangsan";  // a 指向常量池的 zhangsan
        String b = new String("zhangsan");  // b 指向堆中的对象
        System.out.println(a.equals(b));  // true
        System.out.println(a == b);  // false
        System.out.println(a == b.intern());  // true
        System.out.println(b == b.intern());  // false
    }
}

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object)方法确定），则返回池中的字符串，否则将此 String 对象添加到池中，并返回此 String 对象的引用
b.intern() 方法最终返回的是常量池的地址（对象）

在这里插入图片描述

package stringdemo;

public class StringDemo4 {
    public static void main(String[] args) {
        String s1 = "python";  // 指向常量池 python
        String s2 = "java";  // 指向常量池 java
        String s3 = "java";  // 指向常量池 java
        String s4 = new String("java");  // 指向堆中对象
        System.out.println(s2 == s4);  // false
        System.out.println(s2 == s3);  // true
        System.out.println(s2.equals(s4));  // true
        System.out.println(s1 == s2);  // false
    }
}

package stringdemo;

public class StringDemo5 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "zhangsan";
        Person p2 = new Person();
        p2.name = "zhangsan";

        System.out.println(p1.name.equals(p2.name));  // true
        System.out.println(p1.name == p2.name);  // true
        System.out.println(p1.name == "zhangsan");  // true

        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1 == s2);  // false
    }
}

class Person {
    public String name;
}

1.2.5、字符串的特性

String 是一个 final类，代表不可变的字符序列
字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

String s1 = “hello”;
s1 = “haha”;
一共创建了两个对象

在这里插入图片描述

1.2.6、面试题

在这里插入图片描述

1.2.7、String 类的常见方法

在这里插入图片描述

1.2.8、String 类的常见方法一览

在这里插入图片描述

package stringdemo;

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 name = "jack";
        if ("Jack".equalsIgnoreCase(name)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }

        // 3.length 获取字符的个数, 字符串的长度
        String username = "allen";
        System.out.println(username.length());  // 5
        String hobby = "旅游";
        System.out.println(hobby.length());  // 2

        // 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 name1 = "hello,张三";
        // 下面 name1.substring(6) 从索引 6 开始截取后面所有的内容
        System.out.println(name1.substring(6));  // 截取后面的字符, 输出 "张三"
        System.out.println(name1.substring(0, 5));  // 表示从索引 0 开始截取, 截取到索引 5-1=4的位置, 输出 "hello"
        System.out.println(name1.substring(2, 5));  // llo
    }
}

在这里插入图片描述

package stringdemo;

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 = "hello";
        s1 = s1.concat(" world").concat(" together").concat("!");
        System.out.println(s1);  // hello world together!

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

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

        // 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";
        String b = "jack";
        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);  // 我的姓名是john, 年龄是10, 成绩是56.857, 性别是男, 希望大家喜欢我！

        // (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, "lily", 15, 99.6, '女');
        System.out.println(info2);  // 我的姓名是lily, 年龄是15, 成绩是99.60, 性别是女, 希望大家喜欢我！
    }
}

一切随心走_水瓶

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Java面向对象之包装类和String 类

文章目录1、常用类1.1、包装类1.1.1、包装类的分类1.1.2、包装类和基本数据的转换1.1.3、包装类型和 String 类型的相互转换1.1.4、Integer 类和 Character 类的常用方法1.1.5、小练习1.1.6、Integer 类面试题总结1.2、String 类1.2.1、String 类的理解和创建对象1.2.2、创建 String 对象的两种方式1.2.3、两种创建 String 对象的区别1、常用类1.1、包装类1.1.1、包装类的分类针对八种基本数据类型相应的
复制链接

扫一扫