Java（12）Object类，Optional类，浅拷贝与深拷贝

已于 2022-04-27 19:25:52 修改
阅读量904 收藏
点赞数
分类专栏： Java 文章标签： java
于 2022-04-26 19:46:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69015218/article/details/124434638
版权

01 == 与 equals

package;

public class Person01 {
    private String nickname;
    private int age;
    private int gender;

    public Person01() {
    }

    public Person01(String nickname, int age, int gender) {
        this.nickname = nickname;
        this.age = age;
        this.gender = gender;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getAge() {
        return age;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }
}

package Test;

import HashTable;
import Person01;
import org.junit.jupiter.api.Test;

public class Person01Test {
    @Test
    public void test01(){
        int a = 10;
        int b = 10;
        System.out.println(a == b);
        Integer x = 10;
        Integer y = 10;
        System.out.println(x == y);
        System.out.println(x.equals(y));
        Integer aa = 128;
        Integer bb = 128;
        System.out.println(aa == bb);
        System.out.println(aa.equals(bb));
    }
/*
true
true
true
false
true
*/
    @Test
    public void test02(){
        String str01 = new String("abc");
        String str02 = new String("abc");
        System.out.println(str01 == str02);
        System.out.println(str01.equals(str02));
        System.out.println(str01.compareTo(str02));
    }
/*
false
true
0
*/
    @Test
    public void test03(){
        Person01 person01 = new Person01("姓名", 20, 1);
        Person01 person02 = new Person01("姓名", 20, 1);
        System.out.println(person01 == person02);
        System.out.println(person01.equals(person02));
    }
/*
false
false
*/
    @Test
    public void test04(){
        Person01 person01 = new Person01("xm", 20, 1);
        Person01 person02 = new Person01("xm", 20, 1);
        // Person01@dbd940d
        System.out.println(person01);
        // 230528013
        System.out.println(person01.hashCode());
        // dbd940d
        System.out.println(Integer.toHexString(person01.hashCode()));

        // Person01@71d15f18
        System.out.println(person02);
        // 1909546776
        System.out.println(person02.hashCode());
        // 71d15f18
        System.out.println(Integer.toHexString(person02.hashCode()));
    }
/*
Person01@dbd940d
230528013
dbd940d
Day15.Person01@71d15f18
1909546776
71d15f18
*/
    @Test
    public void test05(){
        String[] names = new String[8];
        names[3] = "xm";
        names[6] = "x";
        for (int i = 0; i < names.length; i++) {
            if ("xm".equals(names[i])) {
                System.out.println(names[i]);
                break;
            }
        }
        System.out.println("程序完成");
    }
/*
xm
程序完成
*/
}

02 hash

    @Test
    public void test06(){
        HashTable hashTable = new HashTable();
        int[] hashcodes = hashTable.getHashcodes();
        hashcodes[33] = 33;
        hashcodes[66] = 66;
        hashTable.setHashcodes(hashcodes);
        String[] values = hashTable.getValues();
        values[33] = "xm";
        values[66] = "x";
        hashTable.setValues(values);
        values = hashTable.getValues();

        System.out.println(values[33]);
        System.out.println(values[66]);
        System.out.println("程序完成");
    }
/*
xm
x
程序完成
*/

03 Object类equals方法和hasecode方法

package;

public class Person02 {
    private String nickname;
    private int age;
    private int gender;

    public Person02() {
    }

    public Person02(String nickname, int age, int gender) {
        this.nickname = nickname;
        this.age = age;
        this.gender = gender;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getAge() {
        return age;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        Person02 person02 = (Person02) o;
        if (this.age != person02.getAge()) {
            return false;
        } else if (this.gender != person02.getGender()) {
            return false;
        } else if (!this.nickname.equals(person02.getNickname())) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public int hashCode() {
        int reference = 31;
        return this.age * (this.gender + reference) + this.nickname.hashCode();
    }
}

package Test;

import Person01;
import Person02;
import org.junit.jupiter.api.Test;

public class Person02Test {
    @Test
    public void test01(){
        Person01 person011 = new Person01("姓名", 20, 1);
        Person01 person012 = new Person01("姓名", 20, 1);
        Person02 person021 = new Person02("姓名", 20, 1);
        Person02 person022 = new Person02("姓名", 20, 1);
        System.out.println(person011.hashCode());
        System.out.println(person012.hashCode());
        System.out.println(person021.hashCode());
        System.out.println(person022.hashCode());
        System.out.println(person011 == person012);
        System.out.println(person011.equals(person012));
        System.out.println(person021 == person022);
        System.out.println(person021.equals(person022));
    }
/*
611563982
1615039080
735002
735002
false
false
false
true
*/
}

04 Object类toString方法

package;

public class Person03 {
    private String nickname;
    private int age;
    private int gender;

    public Person03() {
    }

    public Person03(String nickname, int age, int gender) {
        this.nickname = nickname;
        this.age = age;
        this.gender = gender;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public int getAge() {
        return age;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person03{" +
                "nickname='" + nickname + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}


package Test;

import Person03;
import org.junit.jupiter.api.Test;

public class Person03Test {
    @Test
    public void test(){
        Person03 person01 = new Person03("姓名", 20, 1);
        Person03 person02 = new Person03("姓", 29, 1);
        System.out.println(person01.toString());
        System.out.println(person02.toString());
    }
/*
Person03{nickname='姓名', age=20, gender=1}
Person03{nickname='姓', age=29, gender=1}
*/
}

05 浅拷贝与深拷贝

package;

public class Person04 implements Cloneable{
    private String nickname;

    public Person04() {
    }

    public Person04(String nickname) {
        this.nickname = nickname;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package Test;

import Person04;
import org.junit.jupiter.api.Test;

public class Person04Test {
    @Test
    public void test01(){
        Person04 person01 = new Person04("姓名");
        Person04 person02 = person01;
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
        person02.setNickname("姓");
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
    }
    /*
姓名
姓名
姓
姓
     */
    @Test
    public void test02(){
        Person04 person01 = new Person04("姓名");
        Person04 person02 = new Person04(person01.getNickname());
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
        person02.setNickname("姓");
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
    }
    /*
姓名
姓名
姓名
姓
     */
    @Test
    public void test03() throws CloneNotSupportedException {
        Person04 person01 = new Person04("姓名");
        Person04 person02 = (Person04) person01.clone();
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
        person02.setNickname("姓");
        System.out.println(person01.getNickname());
        System.out.println(person02.getNickname());
    }
    /*
姓名
姓名
姓名
姓
     */
}

package;

/**
 * 浅拷贝：指的是你的类本身被拷贝，而没有拷贝类本身属性中的类。
 * 深拷贝：指的是包含类本身和属性类在内的所有类的拷贝。
 */
public class Person05 implements Cloneable {
    private String nickname;
    private Address05 address05;

    public Person05(String 姓名, String 姓) {
    }

    public Person05(String nickname, Address05 address05) {
        this.nickname = nickname;
        this.address05 = address05;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public Address05 getAddress05() {
        return address05;
    }

    public void setAddress05(Address05 address05) {
        this.address05 = address05;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person05{" +
                "nickname='" + nickname + '\'' +
                ", address05=" + address05 +
                '}';
    }
}

package Test;

import Address05;
import Person05;
import org.junit.jupiter.api.Test;

public class Person05Test {
    @Test
    public void test01() throws CloneNotSupportedException {
        Person05 person01 = new Person05("姓名", new Address05("名"));
        Person05 person02 = (Person05) person01.clone();
        System.out.println(person01);
        System.out.println(person02);
        person02.setNickname("姓");
        System.out.println(person01);
        System.out.println(person02);
        Address05 address05 = person02.getAddress05();
        address05.setCity("啦啦啦");
        person02.setAddress05(address05);
        System.out.println(person01);
        System.out.println(person02);
    }
    /*
Person05{nickname='姓名', address05=Address05{city='名'}}
Person05{nickname='姓名', address05=Address05{city='名'}}
Person05{nickname='姓名', address05=Address05{city='名'}}
Person05{nickname='姓', address05=Address05{city='名'}}
Person05{nickname='姓名', address05=Address05{city='啦啦啦'}}
Person05{nickname='姓', address05=Address05{city='啦啦啦'}}
     */
}


package;

/**
 * 浅拷贝：指的是你的类本身被拷贝，而没有拷贝类本身属性中的类。
 * 深拷贝：指的是包含类本身和属性类在内的所有类的拷贝。
 */
public class Person06 implements Cloneable {
    private String nickname;
    private Address06 address06;

    public Person06() {
    }

    public Person06(String nickname, Address06 address06) {
        this.nickname = nickname;
        this.address06 = address06;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public Address06 getAddress06() {
        return address06;
    }

    public void setAddress06(Address06 address06) {
        this.address06 = address06;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return new Person06(this.nickname, (Address06) this.address06.clone());
    }

    @Override
    public String toString() {
        return "Person06{" +
                "nickname='" + nickname + '\'' +
                ", address06=" + address06 +
                '}';
    }
}

package Test;

import Address06;
import Person06;
import org.junit.jupiter.api.Test;

public class Person06Test {
    @Test
    public void test01() throws CloneNotSupportedException {
        Person06 person01 = new Person06("姓名", new Address06("名"));
        Person06 person02 = (Person06) person01.clone();
        System.out.println(person01);
        System.out.println(person02);
        person02.setNickname("姓");
        System.out.println(person01);
        System.out.println(person02);
        Address06 address06 = person02.getAddress06();
        address06.setCity("啦啦啦");
        person02.setAddress06(address06);
        System.out.println(person01);
        System.out.println(person02);
    }
    /*
Person06{nickname='姓名', address06=Address06{city='名'}}
Person06{nickname='姓名', address06=Address06{city='名'}}
Person06{nickname='姓名', address06=Address06{city='名'}}
Person06{nickname='姓', address06=Address06{city='名'}}
Person06{nickname='姓名', address06=Address06{city='名'}}
Person06{nickname='姓', address06=Address06{city='啦啦啦'}}
     */
}
weixin_69015218
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java深入理解浅拷贝和深拷贝
12-21
本文将会深入的探讨一下在拷贝对象中会出现的浅拷贝和深拷贝的情况。 拷贝接口 java中所有的对象都是继承自java.lang.Object。Object对象中提供了一个clone方法，来供我们对java对象进行拷贝。 protected native ...
一文带你认识Java中的Object类和深浅拷贝
weixin_42361467的博客
05-12 120
Object是所有类的父类,其内部定义了一些成员方法,这些方法都会被子类继承,一些通常会被子类重写来使用,学会使用这些方法是很有必要的以下是Object内的成员方法简单介绍,简单介绍下被圈起来的成员方法,而其他的方法需要在线程方面用到…①.Object内的toString方法toString方法主要就是针对对象的内容,即将对象的内容转换成字符串形式返回。
Java的Object类和深拷贝和浅拷贝(面试题)
豆恭梓的博客
06-07 723
两个引用student1和student2指向不同的两个对象，但是两个引用student1和student2中的两个teacher引用指向的是同一个对象，所以说明是浅拷贝。方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。"里面的对象“会在原来的对象和它的副本之间。浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。创建一个指向对象的引用变量的拷贝。
Java深拷贝与浅拷贝
最新发布
weixin_43763430的博客
04-01 745
但是如果对象中的数据需要经过复杂的计算才能得到，（比如排序、计算哈希值），或者需要从PC网络，数据库，文件系统等非常慢速的io中读取，这种情况下就可以使用原型模式从其他已有对象中直接拷贝得到，而不用每次在创建新对象的时候都重复执行这些耗时的操作。如果对象的创建成本比较大，而同一个类的不同对象之间差别不大（大部分字段都相同，在这种情况下可以利用对已有对象（原型）进行复制（拷贝）的方式来创建新对象，以达到节省创建时间的目的，这种基于原型来创建对象的方式就叫做原形设计模式，简称原形模式。
Java对象深拷贝的几种方式
penn
05-16 8381
java对象拷贝的几种方式
Java Object 父类的学习 及Object的clone方法的浅谈深拷贝和浅拷贝
m0_62335629的博客
11-12 461
浅拷贝：不管对象内部的树形是基本数据类型还是引用数据类型，全部拷贝过来、深拷贝：基本数据类型拷贝过来 字符串服用 引用数据类型重新创建Object的克隆是浅克隆。
Java如何对一个对象进行深拷贝？
geomon的博客
08-08 2487
Java如何对一个对象进行深拷贝
JavaScript对象的浅拷贝与深拷贝实例分析
12-03
本文实例讲述了JavaScript对象的浅拷贝和深拷贝。分享给大家供大家参考，具体如下： 1、浅拷贝 仅仅复制对象的引用，而不是对象本身。 var person = { name: 'Alice', friends: ['Bruce', 'Cindy'] } var student...
JS浅拷贝和深拷贝原理与实现方法分析
12-11
本文实例讲述了JS浅拷贝和深拷贝原理与实现方法。分享给大家供大家参考，具体如下： 浅拷贝只会拷贝一层，深层的引用类型改变还是会受到影响。 深拷贝是所有内部的属性还有值都被拷贝了一份，不管深层的引用类型怎么...
Java中的深拷贝和浅拷贝介绍
09-03
对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要...Java中有三种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)、延迟拷贝(Lazy Copy)
java之Object类用法实例
09-04
主要介绍了java之Object类用法实例,是Java程序设计中比较重要的概念,以实例的形式对其定义及用法做了较为深入的讲解,需要的朋友可以参考下
java实现简单的克隆（调用Object的clone方法和浅拷贝，深拷贝)
m0_68402491的博客
05-15 1411
的clone方法是protected修饰需要在克隆类中重写2：编译时异常/受查异常3：向下转型时需要强制类型转换4：克隆类需要设置标记接口。
java浅拷贝和深拷贝
厚Coming的专栏
06-30 754
Object 类的 clone方法执行特定的克隆操作。 首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。(注意：所有的数组都被视为实现接口 Cloneable)否则，此方法会创建此对象的类的一个新实例，并像通过分配，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。所以，此方法执行的是该对象
java copy对象什么意思_什么是 Java 对象深拷贝？
weixin_35711352的博客
02-16 328
作者：吴大山wudashan.com/2018/10/14/Java-Deep-Copy介绍在Java语言里，当我们需要拷贝一个对象时，有两种类型的拷贝：浅拷贝与深拷贝。浅拷贝只是拷贝了源对象的地址，所以源对象的值发生变化时，拷贝对象的值也会发生变化。而深拷贝则是拷贝了源对象的所有值，所以即使源对象的值发生变化时，拷贝对象的值也不会改变。如下图描述：了解了浅拷贝和深拷贝的区别之后，本篇博客将教大家...
java中关于深拷贝的几种方式
wsb8233696的博客
05-28 4870
Object父类有个clone()的拷贝方法，不过它是protected类型的 ，我们需要重写它并修改为public类型，除此之外，子类还需要实现Cloneable接口来告诉JVM这个类上是可以拷贝的。Java提供了序列化的能力，我们可以先将源对象进行序列化，再反序列化生成拷贝对象。需要注意的是，super.clone()其实是浅拷贝，所以在重写User类的clone()方法时，address对象需要调用address.clone()重新赋值。
深拷贝和浅拷贝(Java)
m0_67683346的博客
10-15 1445
java中的深拷贝和浅拷贝问题
Java中对象拷贝，对象的浅拷贝、对象的深拷贝
下雨了亦留此地的博客
04-06 3795
Java中对象的浅拷贝、深拷贝
Java对象深拷贝 终极方案 deep clone an object
stomfeng的专栏
11-03 1381
深拷贝误区：BeanUtils.copy并 不是深拷贝。 实现深拷贝，用Jackson序列化如何实现？ 1. 对象 json字符串 互相转换 (下策) 2. 对象 jsonNode 互相转换 （中策） 3. 对象 TokenBuffer 互相转换 （上策）深拷贝
Java util中的实用工具类（1：Optional与Objects）
随心的专栏
11-26 1789
文章目录1. Optional 类（since 1.8）1.1 构造1.2 类方法列表1.3 常用用法1.4 示例2. Objects类(since 1.7)2.1 方法列表2.2常用方法说明 1. Optional 类（since 1.8） https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html https://blog...
java浅拷贝与深拷贝
08-01
回答: 在Java中，浅拷贝和深拷贝是两种常用的对象拷贝方式。浅拷贝只会复制对象内部的基本数据类型和引用类型变量的引用，而不会复制引用类型变量指向的对象本身。换句话说，浅拷贝创建了一个新对象，但该对象与原始...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值