第十三章 常用类(包装类和 String 相关类)

2023-12-24 13:29:57

一、包装类

1. 包装类的分类

(1)针对八种基本数据类型相应的引用类型—包装类
(2)有了类的特点,就可以调用类中的方法。
在这里插入图片描述

2. 包装类和基本数据类型的转换

(1)jdk5 前的手动装箱和拆箱方式

public class Test {
 
    public static void main(String[] args) {
 
        int n1 = 100;
        //jdk5 前的手动装箱和拆箱方式
        //装箱
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
 
        //拆箱
        int i = integer.intValue();
    }
}

(2)jdk5 及以后的自动装箱和拆箱方式

public class Test {
 
    public static void main(String[] args) {
 
        int n1 = 100;
        //jdk5 及以后的自动装箱和拆箱方式
        //装箱
        Integer integer = n1;// 底层是 Integer.valueOf()
 
        //拆箱
        int i = integer;// 底层是 intValue()
    }
}

3. 包装类和 String 类型的相互转换

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

4. Integer 类和 Character 类的常用方法

public class Test {
 
    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'));//转成小写
    }
}

二、String 类(P466)

1. String 类的理解和创建对象

(1)String 对象用于保存字符串,也就是一组字符序列。
(2)字符串常量 对象是用双引号括起的字符序列。
(3)字符串的字符使用 Unicode 字符编码,一个字符(不区分字母还是汉字)占两个字节。
(4)String类 实现了接口 Serializable【String 可以串行化:可以在网络传输】。
(5)String类 实现了接口 Comparable 【String 对象可以比较大小】。
(6)String 是 final 类,不能被其他的类继承。
(7)String 有属性 private final char value[]:用于存放字符串内容。
(8)一定要注意:value 是一个 final 类型,不可以修改【即 value 不能指向新的地址,但是单个字符内容是可以变化】。
(9)字符串常用构造器
在这里插入图片描述

public class Test {
 
    public static void main(String[] args) {
 
        String s1 = new String();
 
        //public String(String original)
        String s2 = new String("字符串");
 
        //public String(char value[])
        char[] data = {'a','b','c'};
        String s3 = new String(data);
 
        //public String(char value[], int offset, int count) 
        String s4 = new String(data,1,2);
 
    }
}

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

方式一:直接赋值 String s= “hsp” ;
方式二:调用构造器 String s2 = new String(“hsp”);
(1)方式一:先从常量池查看是否有 “hsp” 数据空间,如果有,直接指向;如果没有则重新创建,然后指向。s 最终指向的是常量池的空间地址。
(2)方式二:先在堆中创建空间,里面维护了 value 属性,指向常量池的 hsp 空间。如果常量池没有“hsp”,重新创建,如果有,直接通过 value 指向。最终指向的是堆中的空间地址。
(3)画出两种方式的内存分布图
在这里插入图片描述

3. 字符串的特性

(1)String 是一个 final 类,代表不可变的字符序列。
(2)字符串是不可变的。一个字符串对象一旦被分配,其内容是不可变的。

public class Demo {

    public static void main(String[] args) {
        // 编译器自动优化为 String str = "helloabc";
        String str1 = "hello" + "abc";

        String s1 = "hello";
        String s2 = "abc";
        // 1,先创建一个 StringBuilder sb = StringBuilder()
        // 2. 执行 sb.append("hello");
        // 3. sb.append("abc”);
        // 4. String str = sb.tostring()
        // 最后其实 str -> 堆中的对象(String) value[] -> 池中"helloabc"
        String str2 = s1 + s2;

        String s3 = "helloabc"; // s3 -> 池中"helloabc"
        System.out.println(str2 == s3); // false
    }
}

重要规则:
String c1 = “ab” + “cd”;常量相加,看的是池。
String c2 = a +b;变量相加,是在堆中。

4. String 类的常见方法

String类 是保存字符串常量的。每次更新都需要重新开辟空间,效率较低,因此 java 设计者还提供了 SrimgBuildler 和 StringBuffer 来增强 String 的功能并提高效率。

equals //区分大小写,判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length //获取字符的个数,字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1
lastlndexOf //获取字符在字符串中最后1次出现的索引索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt //获取某索引处的字符,注意不能使用Strtindex]这种方式

toUpperCase //字符串转换成大写
toLowerCase //字符串转换成小写
concat //拼接字符串
replace //替换字符串中的字符
split //分割字符串。对于某些特殊分割字符,我们需要转义符 \
toCharArray //转换成字符数组
compareTo //比较两个字符串的大小。从第一个字符开始比较,如果不同就相减。

public class Demo {

    public static void main(String[] args) {
        String str1 = "cbaa";
        String str2 = "cbaa";
        System.out.println(str1.compareTo(str2));// 0
        String str3 = "aba";
        System.out.println(str1.compareTo(str3));// 2 c-a
        String str4 = "cfa";
        System.out.println(str1.compareTo(str4));// -4 b-f
        String str5 = "cba";
        System.out.println(str1.compareTo(str5));// 1 str1.len - str5.len = 1
    }
}

format //格式字符串

public class Demo {

    public static void main(String[] args) {
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';

        //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);
    }
}

三、StringBuffer 类(P475)

【java.lang.StringBuffer】代表可变的字符序列,可以对字符串内容进行增删。
很多方法与 String 相同,但 StringBuffer 是可变长度的。
StringBuffer 是一个容器。

(1)StringBuffer 的直接父类是 AbstractStringBuilder。
(2)StringBuffer 实现了 Serializable,即 StringBuffer 的对象可以串行化
(3)在父类中 AbstractStringBuilder 有属性 char[] value,不是final。该 value数组 存放字符串内容,因此存放在堆中的。
(4)StringBuffer 是一个 final 类,不能被继承。

1. String VS StringBuffer

(1)String 保存的是字符串常量,里面的值不能更改。每次 String 类的更新实际上就是更改地址,效率较低。// private final char value[]
(2)StringBuffer 保存的是字符串变量,里面的值可以更改,每次 StringBuffer 的更新实际上可以更新内容,不用更新地址,效率较高。 // char value 【这个放在堆】

2. StringBuffer 构造方法

在这里插入图片描述

3. String 与 StringBuffer 转换

public class Demo {

    public static void main(String[] args) {
        // String -> StringBuffer
        String str = "hello";
        // 方式1
        StringBuffer sb1 = new StringBuffer(str);
        // 方式2
        StringBuffer sb2 = new StringBuffer();
        sb2.append(str);

        // StringBuffer -> String
        // 方式1
        String str1 = sb1.toString();
        // 方式2
        String str2 = new String(sb1);
    }
}

4. StringBuffer类 常见方法

(1)增:append
(2)删:delete(start,end)
(3)改:replace(startend,string)
(4)查:indexof【查找子字符串在字符串第一次出现的索引,如果找不到返回 -1】
(5)插:insert
(6)length:获取长度

public class Demo {

    public static void main(String[] args) {
        // 删除索引为 >=start && <end 处的字符
        StringBuffer sb1 = new StringBuffer("hello,Jack.Hi");
        // 5:,
        // 9:k
        sb1.delete(5,9);
        System.out.println(sb1);    // hellok.Hi

        // 改:替换索引6-10的字符,包含6,不包含10
        StringBuffer sb2 = new StringBuffer("hello,Jack.Hi");
        // 6:J
        // 10:.
        sb2.replace(6,10,"Tom");
        System.out.println(sb2);    // hello,Tom.Hi

        // 插:在索引6的位置,插入Tom。原来索引为6的内容自动后移
        StringBuffer sb3 = new StringBuffer("hello,Jack.Hi");
        // 6:J
        sb3.insert(6,"Tom/");
        System.out.println(sb3);    // hello,Tom/Jack.Hi
    }
}

四、StringBuilder 类(P479)

(1)一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。(StringBuilder不是线程安全)。该类被设计用作 StringBuffer 的一个简易替换,用在字特串缓种区被单个线程使用的时候。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。
(2)在 StringBuilder 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。
(3)StringBuilder 和 StringBuffer 均代表可变的字符序列,方法是一样的,所以使用和StringBuffer 一样。

StringBuilder 的方法,没有做互斥的处理,即没有 synchronized 关键字,因此在单线程的情况下使用 StringBuilder。

1. String、StringBuffer 和 StringBuilder 的比较

(1)StringBuilder 和 StringBuffer 非常类似,均代表可变的字符序列,而且方法也一样。
(2)String:不可变字符序列,效率低,但是复用率高。
(3)StringBuffer:可变字符序列、效率较高(增删)、线程安全。
(4)StringBuilder:可变字符序列、效率最高、线程不安全。

文章来源:https://blog.csdn.net/yirenyuan/article/details/135180122
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。