Immutable classes: When an instance of this class is created, the value of its member variable cannot be
Advantages:
1. The value of the thread-safe object cannot be changed, reducing the likelihood of concurrency errors
2. High efficiency when an object needs to be replicated, it only needs to copy the address of the object, without copying the native
Invariance, which guarantees the uniqueness of the hashcode, does not have to recalculate hashcode each time the cache is used, so the usual string as key
3. Easy to test and if the variables in the program are immutable, side effect is relatively small program as long as the written test once the basic no bug
Disadvantages:
Every change requires the creation of new objects that generate a lot of rubbish.
Design method:
Class adds a final modifier to ensure that the class is not inherited
Ensure all member variables private final
No setter available
When initializing variables, use deep copy
Public final class Immutabledemo { private final int[] MyArray; Public Immutabledemo (int[] array) { //This.myarray = array;//Wrong This.myarray = Array.clone (); } }
The Getter method returns to the image clone and does not return itself
String Object
Public final class String implements Java.io.Serializable, Comparable<string>, charsequence{ /** the Value is used for character storage. */ Private final char value[]; /** The offset is the first index of the storage, which is used. */ private final int offset; /** The count is the number of characters in the String. */ private final int count; /** Cache The hash code for the string */ private int hash;//Default to 0 ... . Public String (char value[]) { this.value = arrays.copyof (value, value.length);//Deep copy Operation } ... Public char[] ToCharArray () { //cannot use arrays.copyof because of class initialization order issues Cha R Result[] = new Char[value.length]; System.arraycopy (value, 0, result, 0, value.length); return result; } ...}
Applies to constant pools
Thread Safety
class loader to use strings, immutable classes provide security for proper loading for example, if you want to load the Java.sql.Connection class, and this value is changed to myhacked.connection, it will cause an unknown damage to your database.
Suitable for HashMap
Note: string can change values by reflection mechanism
Create the string "Hello World" and assign the reference s string s = "Hello World"; System.out.println ("s =" + s); Hello World //Get the Value field in String class field valuefieldofstring = String.class.getDeclaredField ("value"); Change the access rights of the Value property valuefieldofstring.setaccessible (true); Gets the value of the ' value ' property on the S object char[] value = (char[]) valuefieldofstring.get (s); Change the 5th character in the array referenced by value value[5] = ' _ '; System.out.println ("s =" + s); Hello_world
Results:
s = Hello Worlds = Hello_world
Reference:
Https://www.cnblogs.com/jaylon/p/5721571.html
Https://www.cnblogs.com/zhiheng/p/6653969.html
The Java Immutable Class (immutable) mechanism is invariant to string