Paras Chawla

1. First, start by reading about algorithms and data structures. To help you with that: What are the most learner-friendly resources for learning about algorithms? 2. Practice. Just like anything else, practicing will help you get better. By the time, you'll find that many algorithms could be re-adjusted to fit multiple needs and that each data structure you master could help you solve a specific set of problems or improve certain areas in an algorithm. My typical resources for problems/puzzles are: http://community.topcoder.com/tc http://icpc.baylor.edu/info/Prob... http://www.leetcode.com/ http://www.careercup.com/ 3. Take your time with #1 and #2 and you will get better. To master interviews, you also need to learn to write flawless code on paper. So practice solving problems, writing code, test, trace and debug them on paper or a whiteboard. Make sure that by the time you write it on your computer, you'd have already solved all test cases including corner cases so the code would just run as is. 4. Last but not least (and this would also increase by time), you'll need to take your time to solve new problems and puzzles. Trust that you have the ability to solve a problem and have the patience to think and solve it. In my experience, many people just give up on a problem without giving themselves a chance to take the time and walk through simple logic to actually solve it. Sometimes, it is OK to start by stating the obvious, easy and what might seem like a dumb solution at first, and then improve that solution or think why do you consider this is a "bad" solution, if you answered that, then you should be able to work on it to improve it.

1.Lamda Expressions I started with lambda expressions as this is probably the most sought after feature in the language after probably Generics/Annotations in Java 5. Here’s the syntax: (argtype arg...) -> { return some expression.. probably using these arguments } What it does is that it reduces the code where it is obvious, such as in an anonymous innerclass. Similar to Scala, type inference is also possible in Lambdas. Consider the following available example: Comparator c=(a, b) -> Integer.compare(a.length(), b.length()); Here, the types of a,b (In this case String, from the Comparator interface) are inferred as the compare method is implemented. The symbol used to separate the block from arguments, -> is quite similar to=> already used in Scala and if you are good at it, there is not much reason to switch as you will feel the way lambdas are implemented in java is inadequate(and verbose), but for a good ‘ol java programmer, this is the way to go. 2.Generic Type changes and improvements Taking clues from Lambdas, generic collections can also infer the data types to be used to an extent. The methods for instance using a generic collection need not specify genric types. Hence, the following method SomeClass.method(); Can be called simply ignoring the type information: SomeClass.method(); The type can be inferred by the method signature, which is helpful in nested calls like myCollection.sort().removeUseless().beautify(); 3. Stream Collection Types (java.util.stream) A stream is a iterator that allows a single run over the collection it is called on. Along with Lambdas, this is another noteworthy feature to watch out for. You can use streams to perform functional operations like filer or map/reduce over collections which can be streamed as individual elements using Stream objects. Streams can run sequentially or parallely as desired. The parallel mode makes use of fork/join framework and can leverage power of multiple cores. Example: List guys=list.getStream.collect(Collectors.toList()) can also be implemented parallely as List guys=list.getStream.parallel().collect(Collectors.toList() Another nice example that reduces the collection to a single item is by calling reduce algorithem. int sum=numberList.stream().reduce(0, (x, y) -> x+y); or, int sum = numberList.stream().reduce(0, Integer::sum); 4. Functional Interfaces (java.util.function) These interfaces contain some default methods which need not be implemented and can run directly from the interface. This helps with existing code – changing interfaces need not make all the classes implementing it implement new methods. This is similar to Traits in Scala and functional interfaces will be compatible with lambdas. 5. Nashorn – The Node.js on JVM This is the javascript engine that enables us to run javascript to run on a jvm. It is similar to the V8 engine provided by chrome over which Node.js runs. It is compatible with Node.js applications while also allowing actual Java libraries to be called by the javascript code running on server. This is exciting to say at the least as it marries scalability and asynchronous nature of Node.js with safe and widespread server side Java middleware directly. 6. Date/Time changes (java.time) The Date/Time API is moved to java.time package and Joda time format is followed. Another goodie is that most classes are Threadsafe and immutable. 7. Type Annotations Now annotations can be used to decorate generic types itself. Even the array objects can be annoted: @NotNull String[] arr; The inclusion of RuntimeVisibleTypeAnnotations and RuntimeInvisibleTypeAnnotations attributes which cause the .class file to save the annotation information. 8.Other – (nice to have) Changes Reflection api is slightly increased with the support of TypeName, GenericString, etc. String.join() method is a welcome addition as a lot of self created utility classes are created instead. So, the following example String abc= String.join(" ", "Java", "8"); Will get evaluated as “Java 8”. In the Collections package, the Comparator interface is revamped and methods like reversed, comparing and thenCOmparing have been added which allow easy customization of comparison over multiple fields. Other libraries like the Concurrency and NIO have also been updated but is nothing noteworthy for following up and is keeping with the changes in the api. Overall, Java8 is well thought of and is making mainstream java concise and picking some good parts of Scala/Clojure for the improving its syntax and addressing much sought features.

1) Java is Easy to learn 2) Java is an Object Oriented Programming Language 3) Java has Rich API 4) Powerful development tools e.g. Eclipse , Netbeans 5) Great collection of Open Source libraries 6) Wonderful community support 7) Java is FREE 8) Excellent documentation support - Javadocs 9) Java is Platform Independent 10) Java is Everywhere