hotel = Optional.of(sheraton);\nif (hotel.isPresent()) {\n hotel.get().getAmenities();\n}\n\nOptional emptyHotel = Optional.empty();\nif (hotel.isPresent()) {\n // never runs\n}”,”language”:”java”}],[“code”,{“code”:”// If the object is always empty,\n// use the empty() static method\nOptional alwaysEmpty = Optional.empty();\n\n\n// If the object is always present,\n// use the of() static method\nOptional alwaysPresent = Optional.of(hotel);\n// Note: If null is passed to Optional.of(),\n// a NullPointerException will be raised!\n\n\n// If the object is sometimes null, sometimes not:\nOptional sometimesNull = Optional.ofNullable(hotel);\n// If the argument is null,\n// it will become an Optional.empty() object”,”language”:”java”}],[“code”,{“code”:”if (optionalHotel.isPresent()) {\n // hotel has a non-null value in it\n}\n\nif (optionalHotel.isEmpty()) {\n // hotel does not have a value\n}”,”language”:”java”}],[“code”,{“language”:”java”,”code”:”optionalHotel.get().getName();\n// If hotel is present, there are no errors.\n// If hotel is empty, a runtime exception is raised!”}],[“code”,{“language”:”java”,”code”:”Hotel hotel = optionalHotel.orElse(defaultHotel);\n// hotel is either optionalHotel.get(), or defaultHotel.\n// hotel is now guaranteed to be non-null.”}],[“code”,{“language”:”java”,”code”:”optionalHotelId.orElseGet(() -> UUID.randomUUID())\n\n// or, the simplified method reference syntax:\nUUID id = optionalHotelId.orElseGet(UUID::randomUUID);\n// note no parenthesis after randomUUID”}],[“code”,{“language”:”java”,”code”:”Hotel hotel = optionalHotel.orElseThrow(\n () -> new MissingHotelException()\n);”}],[“code”,{“language”:”java”,”code”:”optionalHotel.ifPresent(h -> {\n System.out.println(\”Hotel name is: \” + h.getName());\n});”}],[“code”,{“language”:”java”,”code”:”Optional amenityName = optionalHotel\n .map(h -> h.getAmenities())\n .map(a -> a[0])\n .map(a -> a.getName());”}],[“code”,{“language”:”java”,”code”:”String roomsAvailableDisplay = optionalHotel\n .map(h -> h.getAvailableRooms())\n .filter(rooms -> rooms > 0)\n .map(rooms -> \”%d rooms available\”.format(rooms))\n .orElse(\”No rooms available\”);”}],[“code”,{“language”:”java”,”code”:”hotel.map(Hotel::getId) // instance method on type\n .orElseGet(UUID::randomUUID); // static method on class\n\nSet someSet = new HashSet();\nhotel.map(Hotel::getName) // instance method on type\n .filter(String::isEmpty) // instance method on type\n .ifPresent(someSet::add); // instance method on object”}],[“code”,{“language”:”java”,”code”:”String preview = optionalHotel.map(Hotel::getAmenities)\n .filter(amenities -> amenities.size() > 0)\n .map(amenities -> amenities.get(0))\n .map(Amenity::name)\n .map(name -> name.substr(0, 10) + \”…\”)\n .orElse(\”Data not found\”);”}]],”markups”:[[“code”],[“a”,[“href”,”https://kotlinlang.o”]],[“em”],[“a”,[“href”,”https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html”]],[“a”,[“href”,”https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html”]]],”sections”:[[1,”p”,[[0,[],0,”One of the most common exceptions in Java is the “],[0,[0],1,”NullPointerException”],[0,[],0,” – simply put this means that somewhere in your program a method is being called on a “],[0,[0],1,”null”],[0,[],0,” object. “]]],[10,0],[1,”p”,[[0,[],0,”This can be very frustrating and leads to cluttering the code with overly defensive “],[0,[0],1,”null”],[0,[],0,” checks. This frustration has lead to some languages, like JVM-compatible “],[0,[1],1,”Kotlin”],[0,[],0,”, to be created to solve this issue statically by outlawing “],[0,[0],1,”null”],[0,[],0,” unless explicitly allowed in the types.”]]],[1,”p”,[[0,[],0,”How do we reduce these “],[0,[0],1,”NullPointerExceptions”],[0,[],0,” in Java, where we don’t have language-level support like Kotlin? We can use a wrapper class introduced in Java 8, called “],[0,[0],1,”Optional”],[0,[],0,”.”]]],[1,”h1″,[[0,[],0,”Optional”]]],[1,”p”,[[0,[],0,”Very simply put, “],[0,[0],1,”Optional”],[0,[],0,” is a thin wrapper around another object. The optional instance is either present (and non-null), or empty.”]]],[10,1],[1,”p”,[[0,[],0,”However, this doesn’t give us too many benefits since it is just as safe as checking against “],[0,[0],1,”null”],[0,[],0,”. The power with “],[0,[0],1,”Optional”],[0,[],0,” is the many utility methods that is exposes to us:”]]],[1,”h1″,[[0,[0],1,”Optional”],[0,[],0,” methods”]]],[1,”p”,[[0,[],0,”You can break down the Optional methods into a few overarching categories – creating an Optional, checking if the Optional is present, \”unboxing\” the Optional, and interacting/transforming the Optional without unboxing it.”]]],[1,”h2″,[[0,[],0,”Creating an Optional”]]],[1,”p”,[[0,[],0,”There are three ways to create an “],[0,[0],1,”Optional”],[0,[],0,” object – “],[0,[0],1,”Optional.empty()”],[0,[],0,”, “],[0,[0],1,”Optional.of(value)”],[0,[],0,”, and “],[0,[0],1,”Optional.ofNullable(value)”],[0,[],0,”.”]]],[10,2],[1,”p”,[[0,[],0,”Typically if you’re converting a value to optional, use “],[0,[0],1,”Optional.ofNullable”],[0,[],0,”. If you’re returning a known value in a method, use “],[0,[0],1,”Optional.of”],[0,[],0,” or “],[0,[0],1,”Optional.empty”],[0,[],0,”.”]]],[1,”h2″,[[0,[],0,”Check if the Optional has a value”]]],[1,”p”,[[0,[],0,”There are two methods that return whether the optional variable has a value, “],[0,[0],1,”isEmpty()”],[0,[],0,” and “],[0,[0],1,”isPresent()”],[0,[],0,”. They both return a boolean and are opposites of each other.”]]],[10,3],[1,”h2″,[[0,[],0,”\”Unboxing\” the Optional”]]],[1,”p”,[[0,[],0,”There are a few ways to \”unbox\” the value – that is, convert between the “],[0,[0],1,”Optional”],[0,[],0,” type and the underlying type.”]]],[1,”h3″,[[0,[0],1,”.get()”]]],[1,”p”,[[0,[],0,”The first and simplest is “],[0,[0],1,”get”],[0,[],0,”. This returns the value inside the optional if it exists, or throws an exception if it’s missing. Warning, this (intentionally) leads to runtime exceptions, so this might not be what you want!”]]],[10,4],[1,”h3″,[[0,[0],1,”.orElse(defaultValue)”]]],[1,”p”,[[0,[],0,”A much safer alternative to “],[0,[0],1,”get”],[0,[],0,” is “],[0,[0],1,”orElse()”],[0,[],0,”, which accepts a default value to return if the value is missing. This then guarantees that the unboxed value is present, and not null.”]]],[10,5],[1,”h3″,[[0,[0],1,”.orElseGet(() -> defaultValue)”]]],[1,”p”,[[0,[0],1,”orElseGet”],[0,[],0,” functions exactly the same as “],[0,[0],1,”orElse”],[0,[],0,”, but takes a function to run to get the default value instead of the value itself. This is useful to avoid running the default function unless it’s needed.”]]],[10,6],[1,”h3″,[[0,[0],1,”.orElseThrow(() -> new CustomException())”]]],[1,”p”,[[0,[0],1,”get()”],[0,[],0,” throws an exception by default if the value is missing. However, it may be useful to throw an exception of a particular type.”]]],[10,7],[1,”h2″,[[0,[],0,”Interacting with the Optional without unboxing”]]],[1,”p”,[[0,[],0,”Those unboxing methods are useful, but as soon as we unbox the value to its underlying type we lose null safety. Ideally we can keep these values wrapped in an “],[0,[0],1,”Optional”],[0,[],0,” until we get the final value. “],[0,[0],1,”Optional”],[0,[],0,” gives us a few methods to help:”]]],[1,”h3″,[[0,[0],1,”.ifPresent(item -> use(item))”]]],[1,”p”,[[0,[],0,”This method will call the lambda given with the “],[0,[2],1,”unboxed”],[0,[],0,” value if it exists, or else skip the method. This is equivalent to calling “],[0,[0],1,”if (item.isPresent())”],[0,[],0,” first, but more concise.”]]],[10,8],[1,”h3″,[[0,[0],1,”.map(item -> transform(item))”]]],[1,”p”,[[0,[],0,”Map lets you transform the value to a new value. This works exactly like “],[0,[0],1,”.map”],[0,[],0,” in other languages, except it only maps if the value is present. This is chainable!”]]],[10,9],[1,”h3″,[[0,[0],1,”.filter(item -> conditional(item))”]]],[1,”p”,[[0,[],0,”Filter also works the same as in other languages. If the given lambda returns true, then the filter expression returns an “],[0,[0],1,”Optional”],[0,[],0,” of the original value. If it returns false, then it will be an empty “],[0,[0],1,”Optional”],[0,[],0,”. Once again, this can be chained!”]]],[10,10],[1,”h2″,[[0,[],0,”Alternative way to pass Functions”]]],[1,”p”,[[0,[],0,”One note for all the “],[0,[0],1,”Optional”],[0,[],0,” methods that accept functions, like “],[0,[0],1,”map”],[0,[],0,”, “],[0,[0],1,”isPresent”],[0,[],0,”, “],[0,[0],1,”filter”],[0,[],0,”, etc – those can also accept “],[0,[3],1,”Method References”],[0,[],0,”. Method references look like double colons (“],[0,[0],1,”::”],[0,[],0,”). This can reduce some of the boilerplate and increase readability.”]]],[10,11],[1,”h2″,[[0,[],0,”Putting it all together”]]],[1,”p”,[[0,[],0,”In summary, Java’s “],[0,[0],1,”Optional”],[0,[],0,” class gives us a lot of tools to help avoid unnecessary “],[0,[0],1,”NullPointerExceptions”],[0,[],0,” in our code. We can push some of the null safety into the type system itself without needing to use a different language like Kotlin. In some cases, this can make the code more concise, too!”]]],[10,12],[1,”p”,[[0,[],0,”This post only detailed a few of the most common and useful “],[0,[0],1,”Optional”],[0,[],0,” methods. For the full list, the “],[0,[4],1,”Java docs”],[0,[],0,” are a useful reference.”]]]]}’>