Java（day11）object

最新推荐文章于 2024-05-16 15:30:42 发布

五八个

最新推荐文章于 2024-05-16 15:30:42 发布

阅读量184

点赞数

文章标签： java 哈希算法散列表

本文链接：https://blog.csdn.net/qq_44840708/article/details/121922350

版权

Object:

hashCode():返回对象的哈希码值，根据不同的哈希码值区分不同的对象

package cn.tedu.api;
//本类用于顶级父类object的入门让案例
public class TestObject {
    public static void main(String[] args) {
        student s=new student();
        student s1=new student("海绵宝宝",3);
        student s2=new student("海绵宝宝",3);
        System.out.println(s.hashCode());
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}
class student{
    String name;
    int age;
    public student(){
        System.out.println("无参构造");
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("全参构造");
    }
}
运行结果：
无参构造
全参构造
全参构造
356573597
1735600054
21685669

toString()：默认实现对象的地址值，子类重写了tostring()以后，输出的是：对象的类型+属性+属性值

package cn.tedu.api;
//本类用于顶级父类object的入门让案例
public class TestObject {
    public static void main(String[] args) {
        student s=new student();
        student s1=new student("海绵宝宝",3);
        student s2=new student("海绵宝宝",3);
       
        System.out.println(s);
        System.out.println(s1);
    }
}
class student{
    String name;
    int age;
    public student(){
        System.out.println("无参构造");
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("全参构造");
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
无参构造
全参构造
全参构造
student{name='null', age=0}
student{name='海绵宝宝', age=3}

equals()：默认实现比较左右两边值，如果是基本类型，比较的是字面值，如果是引用类型，比较的是引用类型变量的地址值

package cn.tedu.api;
//本类用于顶级父类object的入门让案例
public class TestObject {
    public static void main(String[] args) {
        student s=new student();
        student s1=new student("海绵宝宝",3);
        student s2=new student("海绵宝宝",3);
        
        System.out.println(s1.equals(s2));
    }
}
class student{
    String name;
    int age;
    public student(){
        System.out.println("无参构造");
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("全参构造");
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
无参构造
全参构造
全参构造
false

equals()：重写后比较的是对象的类型+属性+属性值

package cn.tedu.api;

import java.util.Objects;

//本类用于顶级父类object的入门让案例
public class TestObject {
    public static void main(String[] args) {
        student s=new student();
        student s1=new student("海绵宝宝",3);
        student s2=new student("海绵宝宝",3);
        
        System.out.println(s1.equals(s2));
    }
}
class student{
    String name;
    int age;
    public student(){
        System.out.println("无参构造");
    }

    public student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("全参构造");
    }

    @Override
    public String toString() {
        return "student{" +
                "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 age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
运行结果：
无参构造
全参构造
全参构造
true

string：继承了object，object重写了方法

创建string的两种方式：

方式一：String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。

方式二: String str = “abc”;

如果是第一次使用字符串，java会在字符串堆中常量池创建一个对象，再次使用相同的内容时，会直接访问堆中常量池中存在的对象。

在这里插入图片描述

object类中的equals（）的默认实现是通过==来比较的，但是，string类已经重写过了继承自object中的equals（），所以比较两个字符串的具体内容

以下代码：

s1和s11都是创建对象，在堆里开辟了新的空间，所以s1==s11是false

s2和s22都在是常量池，所以地址相同，所以s2==s22是True

package cn.tedu;
//string类的使用
public class TestString {
    public static void main(String[] args) {
        char[] value={'a','b','c'};
        String s1=new String(value);
        String s11=new String(value);

        String s2="abc";
        String s22="abc";
        String s3="ccc";
        System.out.println(s1==s2);
        System.out.println(s1==s11);
        System.out.println(s2==s22);
        System.out.println(s3==s2);
        System.out.println();
        //object类中
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s11));
        System.out.println(s2.equals(s3));
     }
}
运行结果：
false
false
true
false

true
true
false

string继承了object，object中重写了equals（）和hashcode（）

package cn.tedu;
//测试string类的常用方法
public class TestString2 {
    public static void main(String[] args) {
        char[] value={'a','b','c'};
        String s1=new String(value);
        String s2="abc";
        System.out.println(s1.equals(s2));
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
    
    
}
运行结果：
true
356573597
356573597

判断字符串是否以指定元素a开头

char[] value={'a','b','c'};
String s1=new String(value);
System.out.println(s1.startsWith("a"));
运行结果：
True

判断字符串是否以指定元素a结尾

char[] value={'a','b','c'};
String s1=new String(value);
System.out.println(s1.endsWith("a"));
运行结果：
false

将字符串内容大写

char[] value={'a','b','c'};
String s1=new String(value);
System.out.println(s1.toUpperCase());
运行结果：
ABC

将字符串内容小写

char[] value={'a','b','c'};
String s1=new String(value);
System.out.println(s1.toLowerCase());
运行结果：
abc

根据下标获得字符串中对应位置的元素

char[] value={'a','b','c'};
String s1=new String(value);
System.out.println(s1.charAt(0));
运行结果：
a

返回指定字符第一次和最后一次出现的下标

 String s3="asdbhjb";
 System.out.println(s3.indexOf("b"));
 System.out.println(s3.lastIndexOf("b"));
运行结果：
3
6

将指定字符串拼接在字符串的结尾

String s2="abc";
System.out.println(s2.concat("def"));
运行结果：
abcdef

以指定字符作为分隔符，分割当前的字符串

String s5="afbfcfdfe";
String[] a = s5.split("f");
System.out.println(Arrays.toString(a));
运行结果：
[a, b, c, d, e]

去除字符串首尾两端的空格

String s6="           hhhhh     hh     ";
System.out.println(s6.trim());
运行结果：
hhhhh     hh

对字符串进行截取

String s7="abcdefgh";
System.out.println(s7.substring(3));
System.out.println(s7.substring(3,6));
运行结果：
defgh
def

将int类型转化为string类型

System.out.println(String.valueOf(80)+10);
运行结果：
8010

将指定字符串转为byte[]，再用Arrays.tostring()找到ACSII表对应的数字转化为数组

String s7="abcdefgh";
byte[] bs = s7.getBytes();
System.out.println(Arrays.toString(bs));

运行结果：
[97, 98, 99, 100, 101, 102, 103, 104]

拼接：stringBuffer里的append有锁，安全但是较慢；stringBuilder没有锁，不安全但是快

package cn.tedu.review;

import javax.sound.midi.Soundbank;

//测试字符串的拼接
public class TestString3 {
    public static void main(String[] args) {
        String s="abcdefghijklmnopqrstuvwxyz";
        Method2(s);
    }

    private static void Method2(String s) {
        long t1=System.currentTimeMillis();
        StringBuffer sb=new StringBuffer();
        //拼接两次
        for (int i = 0; i <2 ; i++) {
            sb.append(s);
        }
        System.out.println(sb);
        long t2=System.currentTimeMillis();
        System.out.println(t2-t1);
    }
}
运行结果：
abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
0