Java API（十一）：Object类、String类、StringBuiler类

小鹿快跑～

已于 2023-06-13 20:20:19 修改

阅读量483

点赞数 1

分类专栏： Java知识点文章标签： java

于 2022-05-03 10:37:56 首次发布

本文链接：https://blog.csdn.net/qq_45138120/article/details/124508199

版权

Java知识点专栏收录该内容

20 篇文章 6 订阅

订阅专栏

文章目录

Java API

Java API

包含Object类中的toString、equals方法，String类中的toLowerCase、toUpperCase、indexOf、substring、valueOf、startsWith、endsWith、charAt、length基本方法，StringBuiler类。

一、Object

1）在java类继承结构中，java.lang.Obiect类位于顶端

2）定义一个class类，没有使用extends关键字声明父类时，默认继承java.lang.Obiect类

3）Obiect定义了“对象”的基本类型，被子类默认继承

注：一切皆对象

1.1、toString

1）toString用于返回对象的字符串表示

2）所有java类都继承了toString方法，Object自身的toString方法返回的字符串形式是为：类名@hashCode值

public class Test {
    public static void main(String[] ages){
        Test01 test = new Test01(1,2);
        System.out.println(test); //结果为Test.Test01@1540e19d
    }
}

class Test01{
    private int x;
    private int y;

    Test01(int x,int y){
        this.x = x;
        this.y = y;
    }
}

在这里插入图片描述

3）通常我们要使用一个类的toString方法时，就应当重写该方法

4）重写该方法后，返回的字符串没有严格的格式要求，将来可以根据需求而定。但原则上该字符串中应当包含当前对象的属性信息

public class Test {
    public static void main(String[] ages){
        Test01 test = new Test01(1,2);
        System.out.println(test); //结果为x=1,y=2
    }
}

class Test01{
    private int x;
    private int y;

    Test01(int x,int y){
        this.x = x;
        this.y = y;
    }
    
    public String toString(){
        return "x="+x+",y="+y;
    }
}

在这里插入图片描述

5）只有我们定义的类需要重写该方法，JAVA API提供的类通常都已经重写了该方法

1.2、equals

1）通常，当我们需要使用一个类的equals方法时，需要重写它

public boolean equals(Object obj)

2）equals方法的作用是比较当前对象与给定对象内容是否一样（长得像不像）

3）Object提供的equals方法内部就是用“==”实现的多以没有意义

注：未重写equals方法，判断的是栈中两个引用的地址是否相等

4）equals比较时不一定要求所有属性值都要相同，这要结合实际需求而定

5）只有自己定义的类需要重写，JAVA API提供的类基本上都重写了equals

class Test01{
    private int x;
    private int y;

    Test01(int x,int y){  // 有参构造
        this.x = x;
        this.y = y;
    }
    
    public String toString(){
        return "x="+x+",y="+y;
    }

    public boolean equals(Object obj){
        if(obj == null){
            return false;
        }
        if(obj == this){
            return true; //如果调用该方法的对象（this）与参数对象（obj）相等则返回true，否则返回false
        }
        if(obj instanceof Test01){ //判断参数对象是否为本类类型，是则再判断其属性值是否相等
            Test01 p = (Test01) obj;
            return this.x==p.x&&this.y==p.y;
        }
        return false;
    }
}

二、String

2.1、String的特征（不可变）

1）java.lang.String用于封装字符串序列

2）java字符串在内存中采用Unicode编码方式，任何一个字符对应两个字节的定长编码

3）字符串是不变对象，意思是说，字符串内容一旦创建不可改变，若想改变某个字符串内容一定会创建新的对象

2.2、String的特性

1）java语言中可以使用直接量“字符序列”创建字符串序列

String s1 = “123asd”;

2）出于性能考虑，JVM会将字符串字对象缓存在常量池中；对于重复出现的字符串直接量，JVM会首先在缓存池中查找，如果存在即返回该对象

//String演示
public class StringDemo {
    public static void main(String[] ages){
        String s1 = "123asd"; //栈中s1指向123asd在堆中的地址
        String s2 = "123asd"; //栈中s2先查找堆中是否存过123asd，存过的话s2指向之前存放过的123asd在堆中的地址

        String s3 = new String("123asd"); //在堆中创建对象，s3指向新建的对象地址

        System.out.println(s1==s2); //结果为true，s1和s2指向的地址信息相等
        System.out.println(s1==s3); //结果为false，s1和s3指向的地址信息不相等
        System.out.println(s1.equals(s3)); //结果为true，s1和s3的内容相等

        s1 = s1 + "!";
        System.out.println(s1); //结果为123asd!推中会创建新对象，存放一个123asd!的内存空间，s1指向123asd!的内存空间地址
        System.out.println(s2); //结果为123asd，s2指向地址不变
        System.out.println(s1==s2); //结果为false

        /**
         * 编译器的一个优化措施：
         * 当一个计算表达式计算符两边都是自变量时，会直接计算结果，然后将结果编译到class文件中
         * String s4 = "123asd"
         */
        String s4 = "123" + "asd"; //java先编译后运行，计算表达式，计算符两边都是自变量，值肯定固定死的，所以生成.class文件之前，编译器已经将s4的值计算好了，得123asd，所以指向的是123asd已有的地址信息
        System.out.println(s4==s2); //结果为true

        String str1 = "123";
        String str2 = "asd";
        String s5 = str1 +str2; //加号两遍为变量，编译时不进行计算，虚拟机运行时，将123和asd进行拼接会创建一个新对象
        System.out.println(s5==s2); //结果为false
    }
}

在这里插入图片描述

2.3、String的基本方法

String提供的几个简单基本方法：

方法	作用
String toLowerCase()	返回当前字符串的小写形式
String toUpperCase()	返回当前字符串的大写形式
String trim()	返回当前字符串去掉前导和后继的空白（空格\t\n\r…）
int indexOf(String str)	查找str在当前字符串中的位置，返回第一次出现的位置，如果找不到返回-1
String substring(int start,int end)	截取字符串，从指定位置（start）开始截取到指定的位置（end）
String valueOf(XXX xxx)	将java中其他类型转换为字符串
boolean startsWith(String str)	判断当前字符串是否是以指定的字符串开头
boolean endsWith(String str)	判断当前字符串是否是以指定的字符串结尾
char charAt(int index)	获取当前字符串指定下标对应的字符
int length()	返回字符串的长度

（1）、toLowerCase

1）toLowerCase返回字符串的小写形式

2）创建一个新的字符串对象，存放原字符串的大写形式

public class Test {
    public static void main(String[] args) {
        String str = "Hello!";
        str = str.toLowerCase();
        System.out.println(str); //结果为hello!
    }
}

在这里插入图片描述

（2）、toUpperCase

toUpperCase返回字符串的大写形式

public class Test {
    public static void main(String[] args) {
        String str = "Hello!";
        str = str.toUpperCase();
        System.out.println(str); //结果为HELLO!
    }
}

在这里插入图片描述

（3）、indexOf

1）该方法用来查找给定字符串的首字母在当前字符串中的位置

2）重载indexOf方法

方法	作用
int indexOf(String str,int n)	从指定位置开始查找
int lastIndexOf(String str)	查最后出现的下标数，返回最后一次出现的位置

public class Test {
    public static void main(String[] args) {
        //            0123456789123456
        String str = "thinking in java";
        int index = str.indexOf("in");  //查找in在str字符串中的位置
        System.out.println("index:"+index); //返回第一个，没有返回负数-1

        index = str.indexOf("in",5); //从指定位置，第五个开始找，从“4：n”开始
        System.out.println("index:"+index); //结果为5

        index = str.lastIndexOf("in"); //查最后出现的下标数
        System.out.println("index:"+index); //结果为9
    }
}

在这里插入图片描述

（4）、substring

1）截取字符串，从指定位置（start）开始截取到指定的位置（end）

2）substring方法，其参数下标“前包括后不包括”

public class Test {
    public static void main(String[] args) {
        //            0123456789123456
        String str = "thinking in java";
        //截取ing
        String sub = str.substring(5,8); //从下标5开始取到下标8的值，5下标的字母白包含，但8下标的字母不包含
        System.out.println("sub:"+sub); //结果为sub:ing

        sub = str.substring(12); //只传一个参数，指从指定位置开始，截取到字符串末尾
        System.out.println("sub:"+sub); //结果为sub:java
    }
}

在这里插入图片描述

（5）、valueOf

该方法的作用是将java中其他类型转换为字符串

public class Test {
    public static void main(String[] args) {
        int a = 1;
        String strA = String.valueOf(a);
        System.out.println(strA+1); //结果为11
        double b = 1.1;
        String strB = String.valueOf(b);
        System.out.println(strB+1); //结果为1.11
    }
}

在这里插入图片描述

（6）、startsWith endsWith

1）判断当前字符串是否是以指定的字符串开头或结尾的

2）返回boolean型，true或false

public class Test {
    public static void main(String[] args) {
        String str = "thinking in java";
        boolean starts = str.startsWith("thi"); //结果为true
        System.out.println(starts);
        boolean ends = str.endsWith("aava"); //结果为false
        System.out.println(ends);
    }
}

在这里插入图片描述

（7）、charAt

返回字符串指定位置的字符

public class Test {
    public static void main(String[] args) {
        String str = "thinking in java";
        char c = str.charAt(4); //查看第五个字符
        System.out.println(c); //结果为k
    }
}

在这里插入图片描述

经典案例：判断字符序列是否是回文

（8）、length

获取字符序列长度，无论中文还是英文每个字符都是一个长度

public class Test {
    public static void main(String[] ages){
        String str = "我爱JAVA！";
        System.out.println(str.length()); //结果为7
    }
}

在这里插入图片描述

三、StringBuiler类

字符串拼接的性能问题：

假设有个字符串str，需要对str进行多次修改，内存中会疯狂的创建对象，可能会导致内存溢出

public class Test {
    public static void main(String[] ages){
        String str = "a";

        //运行时gc会在后台自动回收str循环后没有被指向的对象
        for(int i=0;i<10000000;i++){
            str += "a";
        }

        /* //运行会报内存溢出
        for(int i=0;i<10000000;i++){
            str += str;
        }
         */
    }
}

1）StringBuiler提供了用于修改字符串内容的相关方法，其内部维护的是一个可变的字符数组，所以修改都是在当前对象内部完成的

2）当频繁修改字符串内容时应当使用当前类来完成

public class Test {
    public static void main(String[] ages){
        String str = "a";

        StringBuilder builder = new StringBuilder("a");
        for(int i=0;i<10000000;i++){
            builder.append("a");
        }
        System.out.println("执行完毕");
    }

3）StringBuiler提供了append、insert、delete、replace等方法，用于对封装的字符序列进行追加、插入、删除、替换等操作

StringBuiler常用方法	作用
StringBuilder append(String str)	向当前字符串末尾追加指定内容
StringBuilder replace(int start,int end,String str)	将指定范围内的字符串替换为指定的内容
StringBuilder delete(int start,int end)	将当前字符串中指定范围内的内容删除
StringBuilder reverse	字符串反转
StringBuilder insert(int index,String str)	将给定字符串插入到指定位置，原位置及后续字符串顺序向后移动

public class Test {
    public static void main(String[] ages){
        String str = "努力学习java";

        /*
        将String转换为StringBuiler
        可以使用有参的构造方法；StringBuiler也有无参构造方法，默认表示空字符串
         */
        StringBuilder builder = new StringBuilder(str);

        /*
        从StringBuilder转换为String使用StringBuilder的toString方法即可
         */
        str = builder.toString();

        /*
        StringBuilder append(String str)
        向当前字符串末尾追加指定内容
        有若干重载方法，参数类型不同，这些重载方法允许追加其他内容（先转换为字符串再追加）
         */
        builder.append("，为了找个好工作！");
        System.out.println(builder.toString()); //结果为努力学习java，为了找个好工作！

        /*
        StringBuilder replace(int start,int end,String str)
        将指定范围内的字符串替换为指定的内容
         */
        builder.replace(9,16,"就是为了改变世界");
        System.out.println(builder.toString()); //结果为努力学习java，就是为了改变世界！

        /*
        StringBuilder delete(int start,int end)
        将当前字符串中指定范围内的内容删除
         */
        builder.delete(0,13);
        System.out.println(builder.toString()); //结果为改变世界！

        /*
        StringBuilder insert(int index,String str)
        将给定字符串插入到指定位置，原位置及后续字符串顺序向后移动
         */
        builder.insert(0,"活着，");
        System.out.println(builder.toString()); //结果为活着，改变世界！
        
        /*
        反转字符串
         */
        builder.reverse();
        System.out.println(builder.toString()); //结果为！界世变改，着活
    }
}

在这里插入图片描述

小鹿快跑～

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java API（十一）：Object类、String类、StringBuiler类

包含Object类中的toString、equals方法，String类中的toLowerCase、toUpperCase、indexOf、substring、valueOf、startsWith、endsWith、charAt、length基本方法，StringBuiler类。
复制链接

扫一扫