Api String类和Object

最新推荐文章于 2024-09-01 03:30:03 发布

睡不醒的小小秦

最新推荐文章于 2024-09-01 03:30:03 发布

阅读量175

点赞数

文章标签：散列表哈希算法数据结构

本文链接：https://blog.csdn.net/weixin_43762083/article/details/122504007

版权

int hashCode() 返回此字符串的哈希码。 boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容 String toString() 返回此对象本身（它已经是一个字符串！）。

int length() 返回此字符串的长度。 String toUpperCase() 所有字符都转换为大写。 String toLowerCase() 所有字符都转换为小写 boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。 boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。

char charAt(int index) 返回指定索引/下标处的 char 值/字符 int indexOf(String str) 返回指定字符在此字符串中第一次出现处的索引。 int lastIndexOf(String str) 返回指定字符在此字符串中最后一次出现处的索引。 String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串 String[] split(String regex) 根据给定元素来分隔此字符串。

String trim() 返回去除首尾空格的字符串 byte[] getBytes() 把字符串存储到一个新的 byte 数组中 String substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标 String substring(int beginIndex, int endIndex) 返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标 static String valueOf(int i) 把int转成String

package cn.tedu.api;

import java.util.Arrays;

/**
 * 本类用于测试String类的常用方法
 */
public class TestString2 {
    public static void main(String[] args) {
        //1.1创建字符串方式1--堆中常量池
        String s1="abc";
        //1.2创建字符串2--堆中new一次，创建一个对象
        char[] c={'a','b','c'};
        String s2=new String(c);
        //1.3打印查看创建好的两个字符串
        System.out.println(s1);
        System.out.println(s2);

        //2.测试常用方法
        /**
         * String也重写了hashcode（）,根据字符串的具体内容生成哈希码值
         * 所以虽然s1与s2的地址值不同，此时生成的哈希码值一致
         */
        System.out.println(s1.hashCode());//96354 串内容为abc
        System.out.println(s2.hashCode());//96354 串内容为abc
        System.out.println(s1.equals(s2));//true,比较的是两个字符串的内容、
        System.out.println(s1.toString());//abc,不推荐写
        System.out.println(s1);//abc
        System.out.println(s1.length());//3
        System.out.println(s1.toUpperCase());//将所有字母转换成大邪恶
        System.out.println(s1.toLowerCase());//转小写，所有字母


        System.out.println(s1.startsWith("a"));//判断该字符串是否以a开头
        System.out.println(s1.endsWith("c"));//判断该字符串是否以c结尾


        System.out.println(s1.charAt(0));//a，在0号位置上的char，根据下标获取字符串指定位置上的字符

        String s3="abckodnskska";
        System.out.println(s3.indexOf("b")); //1，数字b第一次出现的下标是1
        System.out.println(s3.lastIndexOf("a"));//11，数字a最后一次出现的下标


        System.out.println(s1.concat(s3));//abcabckodnskska,拼接字符串，
        System.out.println(s1.concat("cxy"));//abccxy
        System.out.println(s1);//concat打印是abc，如果想用就接一下
        String abc = s1.concat("abc");
        System.out.println(abc);//abcabc

        String s5="     hh   hhhhh    ";
        System.out.println(s5.trim());//hh   hhhhh,去除首尾两端的空格

        String s6="abcdefgh";
        System.out.println(s6.substring(3));//defgh，截取，含头不含尾
        System.out.println(s6.substring(3,6));//def

        String s7="afbfcfdfe";
        String[] fs = s7.split("f");//以指定的字符f分割字符串s7
        System.out.println(fs);//[Ljava.lang.String;@1540e19d
        System.out.println(Arrays.toString(fs));//[a, b, c, d, e]，要使用数组工具类打印数组的数组的具体元素，否则是对象的地址值


        System.out.println(String.valueOf(10));//10，
        System.out.println(String.valueOf(10)+10);//1010,将int类型的参数10转为String类型“10”,所以是拼接的效果


        byte[] bytes = s2.getBytes();//将字符串转为byte类型的数组
        System.out.println(Arrays.toString(bytes));//[97, 98, 99]

    }

}

String的创建方式

方式一：

char[] values = {‘a’,‘b’,‘c’}; String s1 = new String(value); 注意：每new一次，创建一个String对象，存在堆中

方式二：

String s = “abc”; 注意：存在堆中的常量池中，有高效的效果，如果是第二次创建，不会新建注意：== 比较的如果是引用类型，那么是地址值注意：String重写了Object中的toString(),所以可以直接打印字符串的具体内容 String重写了Object中的equals(),所以比较的也是两个字符串的具体内容

package cn.tedu.api;
/**
 * 本类用于学习String类
 */
public class TestString {
    public static void main(String[] args) {
        //创建String对象的方式一
        /**
         * 1.字符串类型底层维护的是char【】，存在堆内存中
         */
            String S1=new String();    //触发String类的构造函数：String（）
            System.out.println("hjdkdfkl"+S1);


            char[] s={'a','c'};
            String s2=new String(s);  //触发String类的构造函数：String（char[] s）
          String s22=new String(s);
            System.out.println("查看s2"+s2);

        /**
         * 2.创建String对象的方式二
         * 效果：如果是第一次创建，会正常放入常量池
         * 但第二创建就不会在常量池新建了，使用的是之前创建好的
         */
        String s3="abc";
        String s33="abc";
        System.out.println("查看s3"+s3);

        System.out.println(s2==s22);//false ,使用方式1 new了两次，是两个对象
        System.out.println(s3==s33);//true,都指向堆中常量池"abc",只有一份
        System.out.println(s2==s3);//false,两种创建方式，一个在堆里，一个在常量池里
        /**
         * Object中equals（）默认使用==比较地址值
         * 但String重写了这个方法，比较的是两个字符串的具体内容
         * 不论创建方式，只要字符串的内容一样，equals（）就返回true
         */
        System.out.println(s2.equals(s2));//true
        String s4="hello";
        System.out.println(s4.equals(s2));
    }
}

1. 顶级父类 java.lang.Object

Object是Java中所有类的超类，Java中的类都直接或者间接的继承自Object
如果一个类没有明确的指定父类，那么这个类默认继承Object
java.lang包是Java的核心包，无需导包，会自动导入

1.1 hashCode()

作用：返回对象对应的哈希码值，Object中默认实现根据对象的地址值生成哈希码值，对象不同，哈希码值应该不同默认实现：根据对象的地址值生成一个唯一的哈希码值 –重写后：根据传入的属性值生成哈希码

1.2 toString()

重写前：打印对象的地址值

注意：我们要牢记Object中的默认实现方式，只要与默认实现不同，说明当前类就重写了Object中的实现至于重写后是什么样的效果，得看具体的重写方式：自定义类Student重写后: 打印Student类型 + 属性 +属性值【这个是我们自己写的类】 String类重写后：打印的是字符串的具体内容【Java自带的类】

1.3 equals()

重写前：等等比较，比较的是两个对象的地址值注意：我们要牢记Object中的默认实现方式，只要与默认实现不同，说明当前类就重写了Object中的实现至于重写后是什么样的效果，得看具体的重写方式：自定义类Student重写后：比较两个对象的类型+属性+属性值 String类重写后:比较的是两个字符串的具体内容

注意1：toString()不是我们主动调用的，是println()层层调用如果你打印某个类的对象时，不想打印地址值，可以在这个类里添加重写的toString() 注意2：equals()与hashCode()的重写要一致，要重写都重写，要不重写都不重写

查找类的4种方式：

查API手册点这里：API手册使用指导

连点两下Shift打开IDEA的搜索,注意勾选"include non-Project items",再搜Object

按住Ctrl点hashCode()

在拓展库External Libraries找到jdk1.8->rt.jar->java.lang.Object public class TestObject {

package cn.tedu.api;

import java.util.Objects;

/**
 * 本类用于顶级父类Object的入门案例
 * 如何使用api？
 * 连点两下shift，勾选，输入要查的类
 * 2.在扩展库External Libraries找到jdk1.8-->rt.jar--->java.lang.object
 */
public class TestObject {
    public static void main(String[] args) {
        Student student = new Student();
        Student student1 = new Student("张三",3,80,"sannianj");
        Student student2 = new Student("张三",3,80,"sannianj");
        /**
         * 5.测试hashcode（）
         * 本方法的作用是返回对象的int类的哈希码值
         * 本方法力求不同的对象返回不同的哈希码值
         * 这样我们就可以根据哈希码值区分不同的对象
         */
        System.out.println(student.hashCode());
        System.out.println(student1.hashCode());
        System.out.println(student2.hashCode());

        //6.测试toString()
        /**
         * 负责打印s2对象的是println（），这个方法会层层向下调用，一直到object中的toString（），object
         * 类中toString（）默认实现打印的是对象的地址值，
         * 子类Student重写了Object中的toString（）,打印的是对象的类型+属性+属性值
         */
        System.out.println(student2.toString());
        System.out.println(student2);

        //7.测试equals
        /**
         * ==比较的是左右两边的值，如果是基本类型，比较的是字面值
         * 比如1和1，3.4和3.4
         * 如果是引用类型，比较的是引用类型变量保存的地址值
         */
        System.out.println(student1.equals(student2));
        /**
         * equals()与hashcode（）逻辑要保持一致，要重写都重写，要不重写都不重写
         * 如果不重写：hashcode（）的哈希码根据地址值生成
         * equals（）底层使用==比较两个对象的地址值
         * 如果重写了：hashcode（）的哈希码值根据重写传入的属性值生成
         * equals（）比较的是重写后类型+所有属性与属性值
         */
    }
}
//1.创建一个学生类
class Student{
    //2.定义属性
    String name;
    int age;
    double score;
    String grade;

    public Student() {
        System.out.println("无");
    }

    public Student(String name, int age, double score, String grade) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.grade = grade;
        System.out.println("you");
    }
生成子类重写的
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", grade='" + grade + '\'' +
                '}';
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age, score, grade);
    }
}
//    abc
//            abc
//96354
//        96354
//        true
//        abc
//        abc
//        3
//        ABC
//        abc
//        true
//        true
//        a
//        1
//        11
//        abcabckodnskska
//        abccxy
//        abc
//        abcabc
//        hh   hhhhh
//        defgh
//        def
//        [Ljava.lang.String;@1540e19d
//        [a, b, c, d, e]
//        10
//        1010
//        [97, 98, 99]

睡不醒的小小秦

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Api String类和Object

int hashCode() 返回此字符串的哈希码。 boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容 String toString() 返回此对象本身（它已经是一个字符串！）。int length() 返回此字符串的长度。 String toUpperCase() 所有字符都转换为大写。 String toLowerCase() 所有字符都转换为小写 boolean startsWith(String prefix) 测试.
复制链接

扫一扫