Class Record
More information about records, including descriptions of the implicitly declared methods synthesized by the compiler, can be found in section 8.10 of The Java Language Specification.
A record class is a shallowly immutable, transparent carrier for a fixed set of values, called the record components. The Java language provides concise syntax for declaring record classes, whereby the record components are declared in the record header. The list of record components declared in the record header form the record descriptor.
A record class has the following mandated members: a canonical constructor, which must provide at least as much access as the record class and whose descriptor is the same as the record descriptor; a private final field corresponding to each component, whose name and type are the same as that of the component; a public accessor method corresponding to each component, whose name and return type are the same as that of the component. If not explicitly declared in the body of the record, implicit implementations for these members are provided.
The implicit declaration of the canonical constructor has the same accessibility
as the record class and initializes the component fields from the corresponding
constructor arguments. The implicit declaration of the accessor methods returns
the value of the corresponding component field. The implicit declaration of the
Object.equals(Object)
, Object.hashCode()
, and Object.toString()
methods are derived from all of the component fields.
The primary reasons to provide an explicit declaration for the canonical constructor or accessor methods are to validate constructor arguments, perform defensive copies on mutable components, or normalize groups of components (such as reducing a rational number to lowest terms.)
For all record classes, the following invariant must hold: if a record R's
components are c1, c2, ... cn
, then if a record instance is copied
as follows:
R copy = new R(r.c1(), r.c2(), ..., r.cn());then it must be the case that
r.equals(copy)
.- API Note:
- A record class that
implements
Serializable
is said to be a serializable record. Serializable records are serialized and deserialized differently than ordinary serializable objects. During deserialization the record's canonical constructor is invoked to construct the record object. Certain serialization-related methods, such as readObject and writeObject, are ignored for serializable records. More information about serializable records can be found in the Java Object Serialization Specification, Section 1.13, "Serialization of Records"., A record class structure can be obtained at runtime via reflection. SeeClass.isRecord()
andClass.getRecordComponents()
for more details. - See Java Language Specification:
-
8.10 Record Types
- Since:
- 16
- External Specifications
-
Constructor Summary
Constructors -
Method Summary
-
Constructor Details
-
Record
protected Record()Constructor for record classes to call.
-
-
Method Details
-
equals
Indicates whether some other object is "equal to" this one. In addition to the general contract ofObject.equals
, record classes must further obey the invariant that when a record instance is "copied" by passing the result of the record component accessor methods to the canonical constructor, as follows:R copy = new R(r.c1(), r.c2(), ..., r.cn());
then it must be the case thatr.equals(copy)
.- Overrides:
equals
in classObject
- Implementation Requirements:
- The implicitly provided implementation returns
true
if and only if the argument is an instance of the same record class as this record, and each component of this record is equal to the corresponding component of the argument; otherwise,false
is returned. Equality of a componentc
is determined as follows:- If the component is of a reference type, the component is
considered equal if and only if
Objects.equals(this.c, r.c)
would returntrue
. - If the component is of a primitive type, using the
corresponding primitive wrapper class
PW
(the corresponding wrapper class forint
isjava.lang.Integer
, and so on), the component is considered equal if and only ifPW.compare(this.c, r.c)
would return0
.
- If the component is of a reference type, the component is
considered equal if and only if
- Parameters:
obj
- the reference object with which to compare.- Returns:
true
if this record is equal to the argument;false
otherwise.- See Also:
-
hashCode
public abstract int hashCode()Returns a hash code value for the record. Obeys the general contract ofObject.hashCode
. For records, hashing behavior is constrained by the refined contract ofRecord.equals
, so that any two records created from the same components must have the same hash code.- Overrides:
hashCode
in classObject
- Implementation Requirements:
- The implicitly provided implementation returns a hash code value derived
by combining appropriate hashes from each component.
The precise algorithm used in the implicitly provided implementation
is unspecified and is subject to change within the above limits.
The resulting integer need not remain consistent from one
execution of an application to another execution of the same
application, even if the hashes of the component values were to
remain consistent in this way. Also, a component of primitive
type may contribute its bits to the hash code differently than
the
hashCode
of its primitive wrapper class. - Returns:
- a hash code value for this record.
- See Also:
-
toString
Returns a string representation of the record. In accordance with the general contract ofObject.toString()
, thetoString
method returns a string that "textually represents" this record. The result should be a concise but informative representation that is easy for a person to read.In addition to this general contract, record classes must further participate in the invariant that any two records which are equal must produce equal strings. This invariant is necessarily relaxed in the rare case where corresponding equal component values might fail to produce equal strings for themselves.
- Overrides:
toString
in classObject
- Implementation Requirements:
- The implicitly provided implementation returns a string which contains the name of the record class, the names of components of the record, and string representations of component values, so as to fulfill the contract of this method. The precise format produced by this implicitly provided implementation is subject to change, so the present syntax should not be parsed by applications to recover record component values.
- Returns:
- a string representation of the object.
- See Also:
-