{"id":6570,"date":"2020-11-20T05:17:36","date_gmt":"2020-11-20T10:17:36","guid":{"rendered":"http:\/\/springframework.guru\/?p=6570"},"modified":"2024-10-21T06:37:49","modified_gmt":"2024-10-21T10:37:49","slug":"using-records-in-java","status":"publish","type":"post","link":"https:\/\/springframework.guru\/using-records-in-java\/","title":{"rendered":"Using Records in Modern Java Development"},"content":{"rendered":"

Java 14 introduces a new feature called Records<\/a>. In Java, Record<\/a> is a special type of Java class.\u00a0It is intended to hold pure immutable data in it. The syntax of a record is concise and short as compared to a normal class<\/p>\n

In this post, I will explain why do we need Java records and how to use them.<\/p>\n

Why Java Records?<\/h2>\n

Whenever you write a Java class, you have to add a lot of boilerplate code. Like<\/p>\n

    \n
  1. \n
      \n
    1. Getter and setter for each field<\/li>\n
    2. A public constructor<\/li>\n
    3. Override the hashCode()<\/code> and equals()<\/code> methods of the Object<\/code> class<\/li>\n
    4. Override the toString()<\/code> method of the Object<\/code> class<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n

      So, if you have to create a Java class, say Student<\/code>, you will have all these functions included.<\/p>\n

      An example Student<\/code> class with boilerplate code is this.
      \nStudent.java<\/strong><\/p>\n

      public class Student {\n\n   private int id;\n   private String firstName;\n   private String lastName;\n   private int grade;\n\n   public Student() {\n   }\n   public Student(int id, String firstName, String lastName, int grade) {\n      this.id = id;\n      this.firstName = firstName;\n      this.lastName = lastName;\n      this.grade = grade;\n   }\n\n   public int getId() {\n      return id;\n   }\n\n   public void setId(int id) {\n      this.id = id;\n   }\n\n   public String getFirstName() {\n      return firstName;\n   }\n\n   public void setFirstName(String firstName) {\n      this.firstName = firstName;\n   }\n\n   public String getLastName() {\n      return lastName;\n   }\n\n   public void setLastName(String lastName) {\n      this.lastName = lastName;\n   }\n\n   public int getGrade() {\n      return grade;\n   }\n\n   public void setGrade(int grade) {\n      this.grade = grade;\n   }\n\n\n   @Override\n   public String toString() {\n      return \"StudentClass{\" +\"id=\" + id + \", firstName='\" + firstName + '\\'' +\n      \", lastName='\" + lastName + '\\'' +\", grade=\" + grade + '}';\n   }\n\n   @Override\n   public boolean equals(Object o) {\n      if (this == o) return true;\n      if (o == null || getClass() != o.getClass()) return false;\n      StudentClass that = (StudentClass) o;\n      return id == that.id &&\n          grade == that.grade &&\n          Objects.equals(firstName, that.firstName) &&\n          Objects.equals(lastName, that.lastName);\n   }\n\n@Override\n    public int hashCode() {\n      return Objects.hash(id, firstName, lastName, grade);\n   }\n}\n<\/pre>\n
      As you can see in the Student<\/code>class, we have getter and setter methods for every field. We have an empty constructor, a parameterized constructor, and so on.<\/p>\n
      If you are using an IDE, such as Intelli J these boilerplate codes can be generated. So, you as a programmer don\u2019t need to type it on your own, but still, you will need to generate them. But, in the end, your class gets bulky and can cause readability issues for other developers.<\/p>\n
      The main advantage of using records is that the methods like equals()<\/code>,\u00a0hashCode()<\/code>,\u00a0toString()<\/code>,\u00a0constructor()<\/code>\u00a0are already generated. It makes the code short and easy to understand.<\/p>\n
      Record Syntax<\/h2>\n
      The syntax of a Java Record modeling a Student is as follows.<\/p>\n
      public record Student(int id, String firstName, String lastName,int age, String PNo) {}\n<\/pre>\n
      The preceding line of code is equivalent to the entire Student class I showed previously. This obviously saves a lot of time and reduces the boilerplate code.<\/p>\n
      Now, I have a Student record with four components: id, firstName, lastName, and grade.<\/p>\n
      Since Java Records is a preview language feature<\/a> in JDK 14, you need to enable preview features to use them. \u00a0A preview language feature means that even though this feature is ready to be used by developers, it could be changed in a future Java release. They may either be removed in a future release or upgraded to permanent features, depending on the feedback received on this feature by developers.<\/p>\n
      So, to enable the Java 14 preview features you need to use --enable-preview -source 14<\/code> in the command line.<\/p>\n
      Now, let\u2019s compile it like this.<\/p>\n
      javac --enable-preview --release 14 Student.java<\/code>.<\/p>\n
      How to Use a Java Record?<\/h2>\n
      A Java record can be used in the same way as a Java class.<\/p>\n
      Here is the code.<\/p>\n
      Student student1 = new Student(1,\"Harry\",\"styles\",10);\nStudent student2 = new Student(4,\"Louis\",\"Tomlinson\",11);\n\n\/\/to string\nSystem.out.println(student1);\nSystem.out.println(student2);\n\n\/\/accessing fields\nSystem.out.println(\"First Name : \" +student1.firstName());\nSystem.out.println(\"Last Name : \" +student1.lastName());\nSystem.out.println(student1.toString());\n\n\/\/equals to\nSystem.out.println(student1.equals(student2));\n\n\/\/hash code\nSystem.out.println(student1.hashCode());\n<\/pre>\n
      As you can see from the code without creating functions like hashCode()<\/code>, equals()<\/code> we can use them in records.<\/p>\n
      Now, let\u2019s use the\u00a0javap<\/code><\/a>command to see what happens when a Record is compiled.<\/p>\n
      From command prompt\/IntelliJ terminal, run javap Student.class
      \n<\/code>
      \n      \"\"<\/a><\/p>\n
      Here is the code of the decompiled Student<\/code> class.<\/p>\n
      public final class Student extends java.lang.Record {\nprivate final int id;\nprivate final java.lang.String firstName;\nprivate final java.lang.String lastName;\nprivate final int grade;\npublic static java.lang.String UNKNOWN_GRADE\n\npublic Student(int id, java.lang.String firstName, java.lang.String lastName, int grade) {\n\/* compiled code *\/ }\n\npublic static java.lang.String getUnknownGrade() {\/* compiled code *\/ }\n\npublic java.lang.String toString() {\/* compiled code *\/}\n\npublic final int hashCode() {\/* compiled code *\/}\n\npublic final boolean equals(java.lang.Object o) {\/* compiled code *\/ }\n\npublic int id() {\/* compiled code *\/ }\n\npublic java.lang.String firstName() {\/* compiled code *\/ }\n\npublic java.lang.String lastName() {\/* compiled code *\/}\n\npublic int grade() {\/* compiled code *\/}\n}\n<\/pre>\n
      As you can see in the preceding code, no setter methods got created. This is because the type of record is final and immutable. Also, notice that the names of the getter methods are not preceded by get<\/code>. Rather they contain the attribute name only.<\/p>\n
      More importantly, note that the Student<\/code> class extends, java.lang.Record<\/code><\/a>. All Java Records implicitly extend java.lang.Record <\/code> class. However, you directly cannot extend the java.lang.Record<\/code> class in your code.<\/p>\n
      The compiler will reject the attempt, like this:<\/p>\n
      $ javac --enable-preview -source 14 Student.java\n\nStudent.java:3: error: records cannot directly extend Record\npublic final class Student extends Record {\n             ^\nNote: Student.java uses preview language features.\nNote: Recompile with -Xlint:preview for details.\n1 error\n<\/pre>\n
      Also in the decompiled class, notice that a declares\u00a0methods like equals()<\/code>,\u00a0hashCode()<\/code>, and\u00a0toString()<\/code>\u00a0to be abstract. These abstract methods rely on\u00a0invokedynamic<\/code> to dynamically invoke the appropriate method which contains the implicit implementation. You can find more information on invokedynamic here<\/a>.<\/p>\n
      Also, all the fields in the record declaration are specified as final.<\/p>\n
      Instance Methods in Record<\/h2>\n
      Just like java classes, we can also include methods in a record definition. Here is an example of the Student Java Record definition from earlier sections. I have added an instance method named nameAsUpperCase()<\/code>.<\/p>\n
      public record Student(int id,String firstName,String lastName,int grade) {\n\npublic String nameAsUpperCase(){\nreturn firstName.toUpperCase();\n}\n\n}<\/pre>\n
      By simply invoking the function nameAsUpperCase()<\/code> we will get the first name in the upper case.<\/p>\n
      The test code is this.<\/p>\n
      System.out.println(\"First Name : \" +student1.nameAsUpperCase());<\/pre>\n
      Let\u2019s run the code and see the output.<\/p>\n
      \"instance<\/a><\/p>\n
      Static Methods in Record<\/h2>\n
      We can also add static methods and variables inside the record definition.<\/p>\n
      public record Student(int id, String firstName,String lastName,int grade) {\npublic static String UNKNOWN_GRADE = \"grade not known\" ;\n\npublic static String getUnknownGrade() {\n    return UNKNOWN_GRADE;\n }\n}\n<\/pre>\n
      From the main class, we can call the getUnknownGrade() <\/code>function.<\/p>\n
      The test code is this.<\/p>\n
      System.out.println(student1.getUnknownGrade());<\/pre>\n
      The output is as follows.<\/p>\n
      \"static<\/a><\/p>\n
      We can also add constructors inside the record definition. There are three types of record constructors. They are compact, canonical, and custom constructors.<\/p>\n
      A compact constructor doesn\u2019t have any arguments. It doesn\u2019t even have parenthesis.<\/p>\n
      This is a typical example of a compact constructor.<\/p>\n
      public Student{\nif(id < 0)\n    throw new IllegalArgumentException(\"student id cannot be negative\");\n}\n<\/pre>\n
      Since id cannot be negative, I am adding an exception here.<\/p>\n
      This is the test code.<\/p>\n
      Student student = new Student(-1,\"loius\",\"lee\",4);\nSystem.out.println(student);\n<\/pre>\n
      As you can see from the output we get an error message.<\/p>\n
      \"error<\/a><\/p>\n
      A canonical constructor takes all the members as its parameters.<\/p>\n
      If you modify a canonical constructor, then it becomes a custom constructor.<\/p>\n
      You can only go for any one of the three constructors mentioned above at one time. This is because adding multiple constructors to a record like a regular class is not allowed.<\/p>\n
      Summary<\/h2>\n
      Java Records is a great way to reduce boilerplate code without sacrificing the reliability of an immutable class.<\/p>\n
      If you have written code for enterprise applications, you might have encountered Lombok<\/a>, a tool to also reduce boilerplate code.<\/p>\n
      There have been talks about Java Records replacing libraries like Lombok, but it is not so. Both are different tools for different things. There is some superficial overlap, but don’t let that distract you.<\/p>\n
      Lombok or similar boilerplate code generation libraries are largely about syntactic convenience. They are typically pre-loaded with some known useful patterns of code. They automate the patterns, according to the annotations you add to your class. Such libraries are purely about the convenience of implementing data-carrying classes.<\/p>\n
      On the other hand, Java Records are a semantic feature. They provide a first-class means for modeling data-only aggregates. They also are designed to close a possible gap in Java\u2019s type system. In addition, as we saw, Records provide language-level syntax for a common programming pattern.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Java 14 introduces a new feature called Records. In Java, Record is a special type of Java class.\u00a0It is intended to hold pure immutable data in it. The syntax of a record is concise and short as compared to a normal class In this post, I will explain why do we need Java records and […]Continue reading<\/a><\/p>\n","protected":false},"author":111,"featured_media":4592,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[20],"tags":[335],"class_list":["post-6570","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java-records"],"jetpack_publicize_connections":[],"aioseo_notices":[],"modified_by":"jt","jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/springframework.guru\/wp-content\/uploads\/2015\/03\/Banner560x292_07web.jpg","jetpack_shortlink":"https:\/\/wp.me\/p5BZrZ-1HY","_links":{"self":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/6570"}],"collection":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/users\/111"}],"replies":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/comments?post=6570"}],"version-history":[{"count":10,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/6570\/revisions"}],"predecessor-version":[{"id":8234,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/6570\/revisions\/8234"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media\/4592"}],"wp:attachment":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media?parent=6570"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/categories?post=6570"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/tags?post=6570"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}