Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what is the knowledge of copying Java". In daily operation, I believe that many people have doubts about the knowledge of copying Java. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the doubts about "what is the knowledge of copying Java?" Next, please follow the editor to study!

1. There are five ways to create an object through the new keyword ❝

This is the most common way to create an object by calling the class's parameter or no-parameter constructor through the new keyword. For example, Object obj = new Object ()

❞❝through the newInstance () method of the Class class

The default is to call the no-parameter constructor of the class to create the object. For example, Person p2 = (Person) Class. ForName ("com.ys.test. Person"). NewInstance ()

❞❝through the newInstance method of the Constructor class

This and the second method class are implemented through reflection. The object is created by specifying a constructor through the newInstance () method of the java.lang.relect.Constructor class. Person p3 = (Person) Person.class.getConstructors () [0] .newInstance (); in fact, the second method uses Class's newInstance () method to create an object, and its internal call is still Constructor's newInstance () method.

❞uses Clone method to ❝

Clone is a method in the Object class, through the object A.clone () method will create an object that is exactly the same as the object A, which is, as the name implies, to create an identical object. Person p4 = (Person) p3.clone ()

❞serializes ❝

Serialization is to store the Java object data in heap memory in some way to disk files or pass them to other network nodes (transferred over the network). Deserialization is the process of restoring the object data in disk files or the object data on network nodes to Java object model. Serialization

❞Java basic replication method

Java assignment is to copy the "object reference". If we want to get a copy of an object, it is impossible to use the assignment operation: changing the value of the new object will modify the value of the old object at the same time.

Public class Client

{

Public static void main (String [] args) throws CloneNotSupportedException

{

Person person = new Person (15, "sowhat", new Address ("Hebei", "Jianhua Avenue"))

Person p1 = person

P1.setAge (45)

System.out.println (p1.hashCode ())

System.out.println (person.hashCode ())

System.out.println ("=")

System.out.println (p1.display ())

System.out.println (person.display ())

}

}

Clone method

If you create a new copy of an object, that is, their initial state is exactly the same, but can later "change their respective states" without affecting each other, you need to use a copy of the object in java, such as the native clone () method. This time, we are talking about deep and shallow copies of Java, which are implemented by calling the clone () method of the Object class. In the Object.class class, the source code is:

/ * *

*.

* performs a "shallow copy" of this object, not a "deep copy" operation.

* as explained above, the clone () method is a shallow copy, not a deep copy.

* @ see java.lang.Cloneable

, /

Protected native Object clone () throws CloneNotSupportedException

This is a method modified with the native keyword, there is a blog about the native keyword, it doesn't matter if you don't understand it, you just need to know that the way to modify it with native is to tell the operating system, I don't realize this method, let the operating system realize it (refer to JNI). We don't need to know exactly how to implement it, we just need to know that the function of the clone method is to "copy the object" and produce a new object. So what is the relationship between the new object and the original object?

Basic types and reference types

Here is another concept to popularize, the difference between "basic type and reference type" in Java. In Java, data types can be divided into two main categories: basic types and reference types. Basic types, also known as value types, are character types char, Boolean types boolean, and numeric types byte, short, int, long, float, double. Reference types include classes, interfaces, arrays, enumerations, and so on. Java divides memory space into "heap and stack". The basic type stores the value directly in the stack stack, while the reference type puts the reference on the stack, and the actual stored value is placed in the heap heap, pointing to the data stored in the heap through the reference in the stack.

The an and b defined in the figure above are basic types whose values are "directly stored on the stack", while c and d are declared by String, which is a reference type, "the reference address is stored on the stack and then points to the memory space of the heap." The following d = c; this statement means that a reference to c is assigned to d, then c and d will point to the same heap memory space.

Shallow copy

Next, use the code to see the effect of the shallow copy.

Package mytest

@ Data//lombok comment

Class Person implements Cloneable

{

Private int age

Private String name

Private Address address

Public Person (int age, String name, Address address)

{

This.age = age

This.name = name

This.address = address

}

@ Override

Protected Object clone () throws CloneNotSupportedException

{

Return super.clone ()

}

Public String display ()

{

Return "Person [age=" + age + ", name=" + name + ", address=" + address + "]"

}

}

@ Data//lombok comment

Class Address

{

Private String province

Private String street

Public Address (String province, String street)

{

This.province = province

This.street = street

}

@ Override

Public String toString ()

{

Return "Address [province=" + province + ", street=" + street + "]"

}

}

Public class Client

{

Public static void main (String [] args) throws CloneNotSupportedException

{

Person person = new Person (15, "sowhat", new Address ("Hebei", "Jianhua Avenue"))

Person clonePerson = (Person) person.clone ()

System.out.println (person)

System.out.println (clonePerson)

/ / the information is exactly the same

System.out.println (person.display ())

System.out.println (clonePerson.display ())

System.out.println ("Information is completely consistent")

System.out.println ("original age:" + person.getAge ())

System.out.println ("original age after cloning:" + clonePerson.getAge ())

System.out.println ("exactly the same age")

System.out.println ("original name hash:" + person.getName () .hashCode ())

System.out.println ("Hash value of cloned name:" + clonePerson.getName () .hashCode ())

System.out.println ("string hash values are exactly the same")

ClonePerson.setName ("xiaomai")

ClonePerson.setAge (20)

ClonePerson.getAddress (). SetStreet (Zhongshan Road)

System.out.println (clonePerson.display ())

System.out.println (person.display ())

System.out.println ("A complete deep copy of age and name has nothing to do with the original value!")

System.out.println ("the modification of address information is a shallow copy")

}

}

The results are as follows:

❝

Mytest.Person@15f550a

Mytest.Person@6b2d4a

Person [age=15, name=sowhat, address=Address [province= Hebei, street= builds South China Street]]

Person [age=15, name=sowhat, address=Address [province= Hebei, street= builds South China Street]]

The information is completely consistent.

Original age: 15

Original age after cloning: 15

The age is exactly the same

Original name hash value:-1432601412

Hash value of cloned name:-1432601412

The string hash value is exactly the same

Person [age=20, name=xiaomai, address=Address [province= Hebei, street= Zhongshan Road]]

Person [age=15, name=sowhat, address=Address [province= Hebei, street= Zhongshan Road]]

❞

Conclusion:

The original object and the new object are two different objects. The copied new object is consistent with the content of the original object, and then the information in the new object is modified, and then the output finds that some of the information in the original object has also changed. The change of basic type and String type will not affect the change of the original object. When other Ojbect types change, the original data will be affected. The above conclusion is called a shallow copy "shallow copy": create a new object, then copy the non-static field of the current object to it, and "copy" the field if the field type is of value type (base type and String); if the field is of reference type, "copy only the reference to the field and not the object to which the reference points to (that is, only the address of the object)." At this point, the reference type field in the new object is equivalent to a copy of the reference type field in the original object, and the reference field in the original object and the new object points to the same object. Therefore, when you modify the address content in the clonePerson, the address content in the original person will change accordingly. Deep copy

If you understand the shallow copy, it will be clear what the deep copy is. So how to achieve deep copy? The clone provided by the Object class can only implement a shallow copy. That is, "copy a new copy of the property contents of the reference type". So, there are two ways to implement deep copy: the "first" is to implement the Cloneable interface and override the clone method for the reference type that needs to be copied, and the "second" is to take advantage of serialization. Next, the two methods are demonstrated respectively.

Deep copy-clone mode

For the above demonstration code, making a deep copy using clone is nothing more than implementing Cloneable for the Address class, and then adjusting the clone method of Person. Let the clone () method be overridden inside each reference type property. Since reference types cannot be deeply copied, we split each reference type into basic types and make shallow copies separately. For example, in the above example, the Person class has a reference type Address (actually String is also a reference type, but the String type is a bit special, which will be explained in more detail later), and we also override the clone method inside the Address class. As follows:

Package mytest

@ Data//lombok comment

Class Person implements Cloneable

{

Private int age

Private String name

Private Address address

Protected int abc = 12

Public Person (int age, String name, Address address)

{

This.age = age

This.name = name

This.address = address

}

@ Override / / clone overload

Protected Object clone () throws CloneNotSupportedException

{

Person person = (Person) super.clone ()

/ / manually clone the address attribute and assign a value to the new person object

Person.address = (Address) address.clone ()

Return person

}

Public String display ()

{

Return "Person [age=" + age + ", name=" + name + ", address=" + address + "]"

}

}

@ Data//lombok comment

Class Address implements Cloneable

{

Private String province

Private String street

Public Address (String province, String street)

{

This.province = province

This.street = street

}

/ / add when deep copy

@ Override

Protected Object clone () throws CloneNotSupportedException

{

Return super.clone ()

}

@ Override

Public String toString ()

{

Return "Address [province=" + province + ", street=" + street + "]"

}

}

Public class Client

{

Public static void main (String [] args) throws CloneNotSupportedException

{

Person person = new Person (15, "sowhat", new Address ("Hebei", "Jianhua Avenue"))

Person p1 = person

P1.setAge (45)

System.out.println (p1.hashCode ())

System.out.println (person.hashCode ())

System.out.println (p1.display ())

System.out.println (person.display ())

System.out.println ("-")

Person clonePerson = (Person) person.clone ()

System.out.println (person)

System.out.println (clonePerson)

/ / the information is exactly the same

System.out.println (person.display ())

System.out.println (clonePerson.display ())

System.out.println ("Information is completely consistent")

System.out.println ("original age:" + person.getAge ())

System.out.println ("original age after cloning:" + clonePerson.getAge ())

System.out.println ("exactly the same age")

System.out.println ("original name hash:" + person.getName () .hashCode ())

System.out.println ("Hash value of cloned name:" + clonePerson.getName () .hashCode ())

System.out.println ("string hash values are exactly the same")

ClonePerson.setName ("sowhat1412")

ClonePerson.setAge (20)

ClonePerson.getAddress (). SetStreet (Zhongshan Road)

System.out.println (clonePerson.display ())

System.out.println (person.display ())

System.out.println ("A complete deep copy of age and name has nothing to do with the original value!")

System.out.println ("the modification of address information is a shallow copy")

}

}

But there is a drawback. Here our Person class has only one Address reference type, but the Address class does not, so we only need to override the clone method of the Address class, but if the Address class also has a reference type, then we also have to rewrite its clone method. If we go on like this, we have to rewrite how many reference types there are. If there are many reference types, then the amount of code will obviously be very large. So this method is not appropriate.

Using serialization

Serialization is writing the object to the stream for easy transmission, while deserialization is reading the object out of the stream. The object written here in the stream is a copy of the original object, because the original object still exists in the JVM, so we can use the serialization of the object to generate a cloned object, and then deserialize it. Note that every class that needs to be serialized implements the Serializable interface, and if there is a property that does not need serialization, you can declare it as transient, that is, excluding it from the clone property.

Package mytest

Import java.io.ByteArrayInputStream

Import java.io.ByteArrayOutputStream

Import java.io.ObjectInputStream

Import java.io.ObjectOutputStream

Import java.io.Serializable

/ * *

* Deep copy of objects using serialization and deserialization

* @ author ljj

, /

Class DeepClone implements Serializable

{

Private static final long serialVersionUID = 1412L

Public Object deepClone () throws Exception

{

/ / Serialization

ByteArrayOutputStream bos = new ByteArrayOutputStream ()

ObjectOutputStream oos = new ObjectOutputStream (bos)

Oos.writeObject (this)

/ / deserialization

ByteArrayInputStream bis = new ByteArrayInputStream (bos.toByteArray ())

ObjectInputStream ois = new ObjectInputStream (bis)

Return ois.readObject ()

}

}

@ Data

Class Person extends DeepClone

{

Private static final long serialVersionUID = 1L

Private int age

Private String name

Private Address address

Public Person (int age, String name, Address address)

{

This.age = age

This.name = name

This.address = address

}

Public String display ()

{

Return "Person [age=" + age + ", name=" + name + ", address=" + address + "]"

}

}

@ Data

Class Address extends DeepClone

{

Private static final long serialVersionUID = 1412L

Private String province

Private String street

Public Address (String province, String street)

{

This.province = province

This.street = street

}

@ Override

Public String toString ()

{

Return "Address [province=" + province + ", street=" + street + "]"

}

Public void setStreet (String street)

{

This.street = street

}

}

Public class Client

{

Public static void main (String [] args) throws Exception

{

Person person = new Person (15, "sowhat", new Address ("Hebei", "Jianhua Avenue"))

Person clonePerson = (Person) person.deepClone ()

System.out.println (person)

System.out.println (clonePerson)

System.out.println (person.display ())

System.out.println (clonePerson.display ())

ClonePerson.setName ("sowhat1412")

ClonePerson.setAge (20)

Address address = clonePerson.getAddress ()

Address.setStreet (Zhongshan Road)

System.out.println (clonePerson.display ())

System.out.println (person.display ())

}

At this point, the study of "what is the knowledge of copying Java" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.