day10_JAVAOOP（五）-优快云博客

本文链接：https://blog.youkuaiyun.com/w114406415/article/details/131798413

本文介绍了JavaAPI的基础概念，特别是Object类中的toString和equals方法。讲解了String类的特点，如不可变性，并详细展示了String的各种方法，包括判断、获取、遍历、转换、分割、替换和正则功能。此外，文章提供了多个示例代码来演示这些方法的使用，并给出了相关练习题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

API

概述

API（Application Programming Interface）应用程序编程接口；JavaAPI是一本程序员的字典，JDK中提供给我们使用的类的说明文档

Object类

概述

java.lang.Object类是Java语言中的根类，即所有类的父类（若一个类没有特别指定父类，那么默认继承自Object类）

根据JDK源码及Object类的API文档，Object类中包含的方法有11个，本次介绍2个：

方法名	说明
`public String toString()`	返回该对象的字符串表示
`public boolean equals(Object obj)`	指示其他某个对象是否与此对象“相等”

toString方法

返回该对象的字符串表示，其实就是对象的类型+@+内存地址值

重写toString方法：快捷键——Alt+Inset

equals方法

调用成员方法equals并指定参数为另一个对象，可以判断这两个对象是否“相同”，此处的“相同”有默认和自定义两种比较方式

默认比较方式

没有重写equals方法的情况下，Object类对这两个对象默认进行==运算符的对象地址比较，只要不是同一个对象，结果必为false

重写equals方法进行自定义比较：详见代码
==和equals的区别

==：

比较引用类型，比较的是对象的地址值
比较基本数据类型，比较值是否相同

equals：

默认比较对象的地址值，（也可以重写equals方法自定义比较）

注：String类中的equals方法比较的不是地址值，人家自己重写了equals方法，在String类中equals比较的是内容

例题：

equals和hashCode的关系

若两个对象需要相等（equals），那他们必须有着相同的哈希码（hashCode）
但如果两个对象有着相同的哈希码，他们却不一定相等
代码演示：

package cn.zhuo_03;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 14:03
 * @Desc:
 */
public class Demo2 {

    public static void main(String[] args) {
        String a = new String("b");
        String b = new String("b");

        //如果两个对象相同，（equals方法返回true），那么他们的hashcode值一定要相同
        System.out.println(a.equals(b));//true

        System.out.println(a.hashCode());//98 你可以把hashcode值看成等价的地址值
        System.out.println(b.hashCode());//98

        //两个对象有着两个相同的hashcode值，他们并不一定相同
        System.out.println(a == b);//false

    }
}

代码演示

package cn.zhuo_02;

import java.util.Objects;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 11:21
 * @Desc: 标准JavaBean格式的类
 */
public class Student extends Object {
    private int id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && age == student.age && Objects.equals(name, student.name);
    }
}

package cn.zhuo_02;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 11:23
 * @Desc:
 *          == 和 equals 的区别
 *              ==：比较是引用类型，比较的是对象的地址值
 *              ==：比较是基本数据类型，比较值是否相同
 *
 *              equals：默认比较是对象的地址值（也可以重写equals方法完成自己的需求）
 *
 *              注:string类中的equals比较不是地址值，自己重写equals方法，所以说在string类中equals比较的是内容
 *
 */
public class Test {

    public static void main(String[] args) {


        String st = new String("");
        System.out.println(st);//打印的结果为空，不是地址值，说明String类重写了equals方法


        Student student = new Student(2002,"张三",18);

        System.out.println(student.toString());//返回该对象的字符串表示

        Student s1 = new Student(2020,"李四",20);
        Student s2 = new Student();
        System.out.println(s2.toString());//Student{id=0, name='null', age=0}

        // ==:比较是引用类型，比较是对象的地址值
        System.out.println(s1 == s2);//false

        // ==：比较是基本数据类型比较值是否相同
        int a = 3;
        int b = 3;
        System.out.println( a == b );//true

        //equals : 比较是引用类型，默认比较是对象的地址值
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s1));//true

        //比较两个对象的内容是否相同
        //我们可以重写equals方法来完成业务需要
        Student s3 = new Student(2020,"李四",20);
        System.out.println(s1.equals(s3));//true
        System.out.println(s2.equals(s3));//false
        System.out.println(s1.equals(s2));//false

    }

}

String类

概述

String代表字符串，Java程序中所有的字符串文字，都可被看做实现此类的实例

String类得特点

字符串不变：字符串的值在创建后不能被更改
因为String对象是不可变的，所以它们可以被共享
String的本质是
- JDK8之前是char[]数组
- JDK8之后是byte[]数组

String类使用步骤

查看类：java.lang.String——此类不需要导入（java.lang包下的所有类无需导入）
查看构造方法

方法名	说明
`public String()`	初始化新建String对象，以使其表示空字符序列
`public String(cahr[] value)`	通过当前参数中的字符数组构造新String
`String(char[] value,int offset,int count)`	通过当前参数中的字符数组的一部分构造新String
`String(byte[] bytes)`	通过使用平台的默认字符集解码当前参数中的字节数组构造新String
`String(byte[] bytes,int offset,int length)`	通过使用平台的默认字符集解码当前参数中的字节数组的一部分构造新String

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 14:29
 * @Desc: String类使用步骤
 */
public class StringDemo2 {
    public static void main(String[] args) {
        //无参构造
        String s = new String();

        //有参构造方法  字符数组
        char[] chars = {'a','b','c','d'};
        String s1 = new String(chars,0,2);//通过当前参数中的字符数组的一部分来构造新的String
        System.out.println(s1);//ab
        String s4 = new String(chars);//通过当前参数中的字符数组来构造新的String
        System.out.println(s4);//abcd

        byte[] bytes ={97,98,99};
        String s2 = new String(bytes,0,2);//通过使用平台的默认字符集解码当前参数中的字节数组的一部分来构造新的String
        System.out.println(s2);//ab
        String s3 = new String(bytes);//通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String
        System.out.println(s3);//abc
    }
}

String类常用的方法

判断功能的方法

注：

String s = " "；//字符串内容为空

String s = null；//字符串对象为空

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 14:42
 * @Desc: String类常用的方法，判断功能的方法
 */
public class StringDemo3 {
    public static void main(String[] args) {

        //创建字符串对象
        String s1 = "helloworld";
        String s2 = "helloworld";
        String s3 = "HelloWorld";

        //boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
        System.out.println("equals:"+s1.equals(s2));//true
        System.out.println("equals:"+s1.equals(s3));//false

        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println("equals:"+s1.equalsIgnoreCase(s3));//true

        //boolean contains(String str):判断大字符串中是否包含小字符串
        System.out.println("contains:"+s1.contains("hello"));//true

        //boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
        System.out.println("startswith:"+s1.startsWith("he"));//true

        //boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
        System.out.println("endswith:"+s1.endsWith("d"));//true

        //boolean isEmpty():判断字符串是否为空。
        System.out.println(s1.isEmpty());//false

        String s4 = " ";//内容为空
        //String s5 = null;//对象为空 相当于 没有对象
        System.out.println(s4.isEmpty());//true
        //System.out.println(s5.isEmpty());//报错 空指针异常
    }
}

获取功能的方法

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 15:09
 * @Desc: 字符串获取相关功能
 */
public class StringDemo4 {

    public static void main(String[] args) {

        //定义一个字符串对象
        String s = "helloworld";

        // int length():获取字符串的长度。
        System.out.println(s.length());
        System.out.println("----------------------");

        // char charAt(int index):获取指定索引位置的字符
        System.out.println(s.charAt(7));
        System.out.println("----------------------");

        // int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
        System.out.println(s.indexOf('l'));
        System.out.println("----------------------");

        // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
        System.out.println(s.indexOf("owo"));
        System.out.println("----------------------");

        // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
        System.out.println(s.indexOf('l', 4));//从第4个索引开始找 l第一次出现的位置
        System.out.println(s.indexOf('k', 4)); // -1 表示没有找到
        System.out.println(s.indexOf('l', 40));// -1 如果没有就返回-1
        System.out.println("----------------------");


        // 自己练习：int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
        System.out.println(s.indexOf("rld", 0));

        System.out.println("----------------------");

        // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
        System.out.println(s.substring(5));//从w开始截取到最后
        System.out.println(s.substring(0));//截取全部
        System.out.println("----------------------");


        // String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引，包左不包右
        System.out.println(s.substring(0, 5));
        System.out.println(s.substring(0, s.length()));
        System.out.println(s.substring(9,10));//不包含10，不报错
        //System.out.println(s.substring(9,12));//包含了10、11，报错
        System.out.println("----------------------");

    }
}

字符串遍历

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 15:25
 * @Desc: 字符串遍历
 */
public class StringDemo5 {
    public static void main(String[] args) {

        String s = "helloworld";

        // 原始版本
        /* System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println(s.charAt(2));
        System.out.println(s.charAt(3));
        System.out.println(s.charAt(4));
        System.out.println(s.charAt(5));
        System.out.println(s.charAt(6));
        System.out.println(s.charAt(7));
        System.out.println(s.charAt(8));
        System.out.println(s.charAt(9));*/

        // 只需要我们从0取到9
        // for (int x = 0; x < 10; x++) {
        // System.out.println(s.charAt(x));
        // }

        //如果长度特别长，我不可能去数，所以我们要用长度功能

        for (int x = 0; x < s.length(); x++){
            //char ch = s.charAt(x);
            //System.out.println(ch);
            //仅仅是输出
            System.out.print(s.charAt(x));
        }

    }
}

转换功能的方法

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 15:29
 * @Desc:
 *          String的转换功能
 *
 *          字符串转成字节数组 getBytes
 *          字符串转成字符数组 toCharArray
 *          字符数组转为字符串 String.valueOf();
 *          int类型转为字符串 String.valueOf();
 *
 *          字符串转为小写 toLowerCase()
 *          字符串转为大写 toUpperCase()
 *
 *          把字符串拼接 concat(String str)
 */
public class StringDemo6 {
    public static void main(String[] args) {

        // 定义一个字符串对象
        String s = "JavaSE";

        // byte[] getBytes():把字符串转换为字节数组。
        byte[] bys = s.getBytes();
        for (int x = 0; x < bys.length; x++) {
            System.out.println(bys[x]);
        }
        System.out.println("----------------");

        // char[] toCharArray():把字符串转换为字符数组。
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("----------------");

        // static String valueOf(char[] chs):把字符数组转成字符串。
        String ss = String.valueOf(chs);
        System.out.println(ss);
        System.out.println("----------------");

        // static String valueOf(int i):把int类型的数据转成字符串。
        int i = 100;
        String sss = String.valueOf(i);
        System.out.println(sss);
        System.out.println("----------------");

        // String toLowerCase():把字符串转成小写。
        System.out.println(s.toLowerCase());
        System.out.println(s);
        System.out.println("----------------");
        // String toUpperCase():把字符串转成大写。
        System.out.println(s.toUpperCase());
        System.out.println("----------------");

        // String concat(String str):把字符串拼接。
        String s1 = "hello";
        String s2 = "world";
        String s3 = s1 + s2;//+号拼接
        String s4 = s1.concat(s2);//方法拼接
        System.out.println(s3);
        System.out.println(s4);
    }
}

分割-替换-去空格的功能方法

代码演示：

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 15:40
 * @Desc: 分割-替换-去空格功能方法
 */
public class StringDemo7 {
    public static void main(String[] args) {

        //创建字符串对象
        String s = "aa|bb|cc";

        //分割方法，返回结果字符串数组
        String[] split = s.split("\\|");
        for (int i = 0; i <split.length ; i++) {
            System.out.println(split[i]);
        }

        System.out.println("============================");

        //替换功能
        String s1 = " hello world ";
        String s2 =s1.replace("l", "y");//将原字符串中的”l“替换成了”y“
        System.out.println(s2);
        String s3 =s1.replace("hello", "yes");
        System.out.println(s3);

        //replaceAll 替换 字符串中所有空格，\\s表示空格
        String s4 = s1.replaceAll("\\s", "");
        System.out.println(s4);

        System.out.println("============================");

        //去除字符串 前后的 空格
        String s5 = " hello world ";
        String trim = s5.trim();//trim()方法去掉字符串前后的空格
        System.out.println(trim);

    }
}

正则功能方法

代码演示：

package cn.zhuo_04;

import java.util.Scanner;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 15:52
 * @Desc: 正则功能方法
 */
public class StringDemo8 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入注册的手机号:");
        String phoneNumber = scanner.next();

        //正则表达式-校验用户写的内容是否满足当前规定
        boolean matchs = phoneNumber.matches("^1[3456789]\\d{9}$");//里面是正则表达式，不会就百度

        //System.out.println(matchs);
        if(matchs){
            System.out.println("输入正确");
        }else {
            System.out.println("输入错误");
        }
    }
}

String类的练习

练习一

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 16:21
 * @Desc: 把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
 */
public class StringDemo9 {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "helloWORLD";

        // 先获取第一个字符
        String s1 = s.substring(0, 1);
        // 转成大写
        String s2 = s1.toUpperCase();

        // 获取除了第一个字符以外的字符
        String s3 = s.substring(1);

        // 转成小写
        String s4 = s3.toLowerCase();
        // 拼接
        String s5 = s2.concat(s4);
        System.out.println(s5);

        // 优化后的代码
        // 链式编程
        String result = s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase());
        System.out.println(result);
    }
}

练习二

package cn.zhuo_04;


import java.util.Scanner;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 16:26
 * @Desc: 键盘录入一个字符串，统计字符串中大小写字母及数字字符个数
 */
public class StringDemo10 {

    public static void main(String[] args) {


        //键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();

        //定义三个统计变量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //遍历字符串，得到每一个字符
        for(int x=0; x<s.length(); x++) {
            char ch = s.charAt(x);
            //拿字符进行判断
            if(ch>='A'&&ch<='Z') {
                bigCount++;
            }else if(ch>='a'&&ch<='z') {
                smallCount++;
            }else if(ch>='0'&&ch<='9') {
                numberCount++;
            }else {
                System.out.println("该字符"+ch+"非法");
            }
        }

        //输出结果
        System.out.println("大写字符："+bigCount+"个");
        System.out.println("小写字符："+smallCount+"个");
        System.out.println("数字字符："+numberCount+"个");

    }
}

练习三

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 16:36
 * @Desc: 求大串中小串的个数
 */
public class StringDemo11 {

    public static void main(String[] args) {

        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjavajava";
        // 定义小串
        String minString = "java";

        //循环  while
        //找java在大串中第一次出现的位置
        int count =0;
        int index;
        while ( (index = maxString.indexOf(minString)) != -1 ){
            count++;
            //重新计算新的大串开始位置， index + minSring.length()  4+4=8 新串的起始索引
            maxString = maxString.substring(index+minString.length());

        }
        System.out.println("java出现的次数为："+count);//正确：7次
    }
}

简化方法

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 16:48
 * @Desc: 求大串中小串的个数简化方法
 */
public class StringCount {
    public int getstr(String maxString , String minString){


        int count =0;
        int index;
        while ( (index = maxString.indexOf(minString)) != -1 ){

            count++;

            //重新计算新的大串开始位置， index + minSring.length()  4+4
            maxString = maxString.substring(index+minString.length());

        }
        return count;
    }
}

package cn.zhuo_04;

/**
 * @Auther: 不学无墅
 * @Date: 2023/7/18 16:49
 * @Desc: 求大串中小串的个数简化方法
 */
public class StringTest {
    public static void main(String[] args) {

        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjavajava";
        // 定义小串
        String minString = "java";

        //调用方法
        StringCount stringCount = new StringCount();
        int s = stringCount.getstr(maxString, minString);
        System.out.println(s);
    }
}