Java中常用的类（一）：Object 类、String 类、StringBuffer类、StringBuilder 类

最新推荐文章于 2024-07-30 14:53:52 发布

ONESTAR博客

最新推荐文章于 2024-07-30 14:53:52 发布

阅读量3.9k

点赞数 4

分类专栏： Java基础文章标签： Java常用的类 Object类 String类 StringBuffer类 StringBuilder类

本文链接：https://blog.csdn.net/One_L_Star/article/details/93756680

版权

Java基础专栏收录该内容

33 篇文章 43 订阅

订阅专栏

1、StringBuffer 常用方法使用

四、StringBuilder 类

一、Object 类

Object类是Java中的根类，是所有类的父类，Object类中所有方法子类都可以使用。在Object类中有很多方法，这里讲述 equals方法和toString方法。

1、equals 方法

用于比较两个对象是否相同
实际是使用两个对象的内存地址进行比较
equals 方法内部使用的是 == 比较运算符
源码分析：
```
public boolean equals(Object obj){
    return (this == obj);
}
```
源码中，equals 方法传入 Object 类，由于 Object 类是所有类的父类，所以任何参数都能传入，返回值中 “==” 表示比较对象内存的地址，由于对象都是 new出来的，所以地址肯定不同，返回值为 false。在实际开发中，比较地址是没有什么实际意义的，往往需要重写 equals 方法，用来比较成员变量。

实例分析：

//创建Person类继承Object类
public class Person extends Object {
    private int age;
    private String name;

    //带参构造方法
    public Person(String name,int age){
        this.age = age;
        this.name = name;
    }

    //重写父类的代码
    public boolean equals(Object obj)
    {
        //进行非空判断
        if(obj == null)
        {
            return false;
        }
        //和自己比较
        if(this == obj)
        {
            return true;
        }
        //判断是否是同一类
        if(obj instanceof Person)
        {
            Person p = (Person)obj;     //需要对obj进行向下转型
            return this.age == p.age;
        }
        return false;
    }
}
//在main中进行调用
public static void main(String[] args)
{
    Person p1 = new Person("Tom",18);    //创建对象p1
    Person p2 = new Person("Tim",18);    //创建对象p2
    boolean b = p1.equals(p2);    //调用重写的equals方法比较p1和p2的成员
    System.out.println(b);    //返回true
}

注意事项:
(1) 使用 equals(Object obj) 传递参数时，实际上是隐藏了多态的向上转型：Object obj = p2，将 p2 子类型提升为 Object 父类型，因此不能直接调用子类特有成员，需要对obj参数进行类型的向下转型：Person p = (Person)obj;
(2) 为了防止不同类进行比较，需要对参数是否同类进行判断
(3) 为了防止空参数传入，需要进行非空判断
(4) 为了防止和自己进行比较，需要对自己进行判断

2、toString 方法

源码分析：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

用于返回该对象的字符串表示
该方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：getClass()+'@'+Interger.toHexString(hashCode())
由于 toString 方法返回的是结果的内存地址，在实际开发中，往往需要按照对象的属性得到响应的字符串表象形式，所以需要重写toString 方法

实例分析：

//创建Person类继承Object类（这里省略了set、get方法）
public class Person extends Object {
    private String name;
    private int age;
    //重写Object类中的toString方法
    public String toString()
    {
        return name + age;
    }
}
//在main中调用
public static void main(String[] args)
{
    Person p1 = new Person("Tom",18);    //创建p1对象
    System.out.println(p1);    //输出一个语句，写的是一个对象，则默认调用的是toString方法
}

注意事项：
(1) 重写 Object 类中的 toString 方法，让其返回成员信息
(2) 在输出语句中，直接写入一个对象，会默认调用 toString 方法

二、String 类

String 类代表字符串，Java程序中所有字符串字面值都作为此类的实例实现。字符串是常量，一旦创建就不能改变，字符串本身是不能改变的，但存放字符串的地址可以改变，引用变量指向的内存可以改变。

1、字符串定义方式：

String str1 = "qwer";
String str2 = new String("qwer");
System.out.println(str1 == str2);    //false
System.out.println(str1.equals(str2));    //true

String str1 = "qwer"; ===>在内存中只有一个对象，这个对象在字符串常量池中
String str2 = new String("qwer"); ===>在内存中有两个对象，一个对象是在堆中的new String()，另一个对象是字符串 “qwer”本身对象，在字符串常量池中
str1 == str2 为 false 是因为引用类型比较的是地址，肯定不同
str1.equals(str2) 为 true 是因为String类将equals方法进行了重写，建立了字符串自己的判断依据，通过字符串对象中的字符来判断

2、String 类常用构造方法

String(byte[] bytes)：将字节数组中的每个字节，通过查询编码表后得到的结果，默认编码表一个汉字采用两个字节表示
String(byte[] bytes，int offset，int length)：将字节数组的一部分转成字符串
String(char[] value)：将字符数组转成字符串
String(char[] value，int offset，int count)：将字符数组的一部分转换成字符串

代码实例：

public static void main(String[] args)
{
    //String(byte[] bytes)
    byte[] bytes = {97,98,99,100};
    String str = new String(bytes); //调用String类构造方法，传递字节数组
    System.out.println(str);    //将字节数组中的每个字节，通过查询编码后得到结果

    //String(byte[] bytes,int offset,int length)
    byte[] bytes1 = {97,98,99,100};
    String str1 = new String(bytes1,1,2);
    System.out.println(str1);   //将字节数组的一部分转换成字符串

    //String(char[] value)
    char[] ch = {'a','b','c','d'};
    String str2 = new String(ch);   //将字符数组转换成字符串
    System.out.println(str2);

    //String(char[] value,int offset,int count)
    char[] ch2 = {'a','b','c','d'};
    String str3 = new String(ch2,1,2);   //将字符数组的一部分转换成字符串
    System.out.println(str3); 
}

3、String 类的字符串的长度

str.length()：返回str字符串长度
str.substring(int beginIndex)：返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
str.substring(int beginIndex,int endIndex)：返回一个新字符串，内容为指定位置开始到指定位置结束所有字符

逻辑实例：

String str = "abcdef";
int len = str.length();    //返回字符串长度
String s1 = str.substring(1); //返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
String s2 = str.substring(2, 4);//返回一个新字符串，内容为指定位置开始到指定位置结束所有字符

4、String 类其他方法

int indexOf(int ch ) ：在给定字符串中查找字符(ASCII),找到返回字符数组所对应的下标找不到返回-1
int indexOf(int ch，int fromIndex)：从指定的下标开始查找某个字符，查找到返回下标，查找不到返回-1
int indexOf(String str)：在给定符串中查找另一个字符串
int indexPf(String str，int fromlndex)：从指定的下标开始查找某个字符串
byte[] getBytes() 把该字符串转换成字节数组
char[] toCharArray() 把该字符串转换成字符数组
String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换
String replace(String old,String new) 在该字符串中，将给定的旧字符串，用新字符串替换
String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串
String toLowerCase() 把该字符串转换成小写字符串
String toUpperCase() 把该字符串转换成大写字符串

三、StringBuffer 类

StringBuffer 又称为可变字符序列，它是类似于 String 的字符串缓冲区，通过某些方法调用可以改变的该序列的长度和内容。其实StringBuffer是一个字符串的缓冲区，就是个容器，容器中可以装很多个字符串，并且能够对其中的字符串进行各种操作。

1、StringBuffer 常用方法使用

append(String str)：将制定字符串追加到此字符序列
delete（int star，int end）：移除指定字符串
insert(int offset，String str)：在指定位置插入
replace(int star，int end，String str)：替换指定范围的内容
reverse()：将字符序列反转
toString()：返回此序列中数据的字符串表示形式
substring(int star，int end)：从指定位置开始到指定位置结束，截取该字符串缓冲区，返回新字符串

逻辑实例：

//创建一个字符串缓冲区对象，用于存储数据
StringBuffer sb = new StringBuffer();
sb.append("qwert");    //添加字符串
sb.insert(2,"as");    //在指定位置插入
sb.delete(1,4);    //删除
sb.replace(1,4,"dfs");    //替换指定范围内的内容
String str = sb.toString();    //返回此序列中数据的字符串表示形式

注：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己，所以 StringBuffer 字符序列的长度和内容