Java 7 & 8 - A&BP CC

Editor's Notes

• #2: Welkom, onszelf voorstellen, ABP, structuur avond, volgende workshops, kleine inleiding waarom deze workshop interessant zou moeten zijn -> self assessment, enterprise omgeving Java 7
• #5: String in switch is faster than if … equals else … (Java compiler generates generally more efficient bytecode). Uses the String.equals method.
• #6: The try-with-resources statement is a try statement that declares one or more resources. A resource is as an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource. The resource is closed automatically in a finally block that’s added at compile time (http://www.oracle.com/technetwork/articles/java/trywithresources-401775.html)
• #7: Eg. The classes InputStream and OutputStream, in Java SE 7 and later, implements the interface java.lang.AutoCloseable. The resource is closed automatically in a finally block that’s added at compile time (http://www.oracle.com/technetwork/articles/java/trywithresources-401775.html)
• #8: You can replace the type arguments required to invoke the constructor of a generic class with an empty set of type parameters (<>) as long as the compiler can infer the type arguments from the context (so no-go for anonymous inner classes!). Note that omitting the diamond operator doesn’t have the same effect. You’ll get an unchecked conversion warning, because the instantiation refers to the raw type instead of the generic class.
• #9: Pipeline is used to group Exceptions that should be handled the same way. This feature can reduce code duplication and lessen the temptation to catch an overly broad exception.
• #10: Note that NoSuchFieldException extends ReflectiveOperationException. The compiler is smart enough to determine that only NoSuchFieldException can be thrown so it’s not mandatory to add the ReflectiveOperationException to the method signature. Advantage can be that if you have multiple implementations of a ReflectiveOperationException, you do not need to list them all in the catch declaration. This again saves time.
• #11: Integral types (byte, short, int, and long) can also be expressed using the binary number system. Any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This can improve the readability of your code.
• #12: Lots of interesting stuff in there, be sure to have a look at that package! A zip file system provider is also available in JDK 7 (check out http://docs.oracle.com/javase/7/docs/technotes/guides/io/fsp/zipfilesystemprovider.html for more information). Stream: Element not cached, can’t move back and forth without first buffering Buffer: Data is read into a buffer to be processed later, can move back and forth. More flexible during processing but the buffer might not contain all data necessary to process it. Blocking: read(), write() -> Thread blocked until data is read of fully written Non-blocking: Thread gets what’s available (possibly nothing) or thread writes but doesn’t wait until it’s fully written. -> Single thread can manage multiple inputs and outputs Files: Static methods that operate on files, directories, or other types of files. FileSystem: Provides an interface to a file system and is the factory (getInstance()) for objects to access files and other objects in the file system. Path: Offers more functionalities than File, File now has a toPath()-method. Similar methods compared to File but methods now throw Exceptions (example: delete()) More properties available for consulting (DOS and POSIX), returns null if it isn’t supported on the system.
• #14: Listens to events that take place in the directory that’s being watched. watchKey.take(): Retrieves and removes next watch key, waiting if none are yet present. Returns: the next watch key watchKey.reset(): Resets this watch key. If this watch key has been cancelled or this watch key is already in the ready state then invoking this method has no effect. Otherwise if there are pending events for the object then this watch key is immediately re-queued to the watch service. If there are no pending events then the watch key is put into the ready state and will remain in that state until an event is detected or the watch key is cancelled. Returns: true if the watch key is valid and has been reset, and false if the watch key could not be reset because it is no longer valid
• #15: Crawls through a directory, skips, svn-folders and prints out the directories and files found.
• #16: A divide and conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same (or related) type, until these become simple enough to be solved directly. Tasks are divided into smaller parts to be processed, results are combined into one
• #17: ForBlur.java is an example of a picture being blurred by going through it’s pixels
• #18: The heap is partitioned into a set of equal-sized heap regions, each a contiguous range of virtual memory. G1 performs a concurrent global marking phase to determine the liveness of objects throughout the heap. After the mark phase completes, G1 knows which regions are mostly empty. It collects in these regions first, which usually yields a large amount of free space. This is why this method of garbage collection is called Garbage-First. G1 compacts sufficiently to completely avoid the use of fine-grained free lists for allocation, and instead relies on regions. Also, G1 offers more predictable garbage collection pauses than the CMS collector, and allows users to specify desired pause targets.
• #19: Hot topic op Devoxx. Java releases komen sneller en sneller uit dus belangrijk om bij te blijven
• #20: Functionali programming: Immutable data. State is handled via parameter passing, avoids side effects. Split up the problem in a chain of functions that need to be executed where each function takes input and returns a result. Think about what transformations need to happen. Recursion is used more often. Functions are first class citizens. Data flow. OOP: Mutable. State changes. Write the exact steps in detail to solve a particular problem. Control flow. Note that when using brackets in a lambda expression ‘;’s are mandatory at the end of the line!! Java compiler compiles lambda expressions and convert them into private methods of the class.
• #21: Note how the type of param can be left out and parentheses aren’t necessary if there’s only one param.
• #22: Specify implementations in your interface! This also allows existing interfaces to be extended with new functionalities without breaking backwards compatibility. Not limited to only one default method.
• #24: A warning is given by your IDE when more than one method is specified inside a FunctionalInterface. Trying to compile the project will also fail. When omitting the @FunctionalInterface annotation, the project will compile and a lambda expression can be used to implement calculate(int a). Some of the functional interfaces might be familiar if you’ve used Guava such as Predicate. Supplier: provides objects
• #25: Anonymous inner class vs lambda. Notice how you are actually passing a function as a parameter. Assigning the lambda to a variable is usually skipped.
• #26: :: syntax was introduced in Java 8 to reference methods
• #27: These method references are possible since they accept a param of F and have a result of T. forEach accepts a Consumer<T> where T is the type of an element of the Collection.
• #28: Picking the right constructor method is context dependent, in this case since BookFactory defines a method with 2 params, the second constructor of Book is used.
• #29: Why stream? Not a data structure that stores elements, it conveys elements from a source Does not modify its source (functional in nature), instead it produces a new stream Laziness-seeking, opportunity for optimalisation (example: find first 3 strings with even number of characters, doesn’t need to traverse through all elements) Collections have an finite size where as streams do not Each element of a stream is only visited once thus a new stream must be generated to revisit the same elements
• #31: putIfAbsent: If the specified key doesn’t have a value (null) assign the specified value to it. Returns null if the value was assigned, otherwise return the value.(note: already existed in ConcurrentMap in Java <8, now available to all Maps) forEach: execute the consumer for each element computeIfPresent: If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value computeIfAbsent: If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null getOrDefault: Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key
• #35: Human time: separate fields for years, months, days, hours, minutes, seconds, and, in line with the current fashion, nanoseconds. Machine time: number of milliseconds since epoch, which you may obtain, for example, via System.currentTimeMillis() call. This does not replace the existing Data API, it simply offers a better solution for doing calculations with dates.
• #37: sun.misc.BASE64Encoder wasn’t even documented…
• #38: Basic vs Url: Url-friendly encoding Notice output no longer than 76 chars and ends with carriage return followed by a line feed
• #39: Note that the container annotation is still used but this time the Java compiler is responsible for wrapping the repeating annotations into a container annotation.
• #40: Note that the container annotation is still used but this time the Java compiler is responsible for wrapping the repeating annotations into a container annotation.