- When you write code in Groovy, the compiler works for you. When you write code in Java, you work for the compiler ;)
- Iteration: each in Groovy is forEach in Java 8
- null is synonymous to word evil ;)
- collect in Groovy is stream() in Java 8
List<Integer> values = Arrays.asList(1,2,3,4,5)
values.stream().map(e-> e*2).forEach(System.out::println); //java 8
def values = [1,2,3,4,5]
values.collect{2 * it}.each{println it}
values.stream().filter(e->).findFirst().orElse(0)); //to avoid null when not found...groovy find returns null
def values = [1,2,3,4]
println values.inject(0) {c, e -> c + e} //starts with 0, adds 1, takes the result adds 2 and goe on.
reduce - Java 8
values.stream().reduce(0, (c,e) -> c + e));
map gathers the data, reduce scatters the data
- def names = [‘Jake’, ‘Sara’, ‘Pete’]
Groovy: join method of collections separated by commans
:)
Make it a law: Arrest people for writing code like for(int i=0; i<....)
Java 8:
names.stream().map(String::toUpperCase).collect(joining(“, “))); //joining is a static method from Collectors class
- Unfamiliar things in Java 8 that are really nice (late in the party) and not there in Groovy
- default method: List has been around for awhile. we called stream on List.
- A method you can implement in interface is default method.
- You can override default method, if you don’t override, it is available automatically. Abstract base classes can have state, fields. Interfaces cannot.
- Any method in the class hierarchy takes precedence over the interface default method.
- two interfaces with same default methods: throws error.
- stream is implememnted using default method in Java 8
- Java guys got promoted to Architects so that they don’t have to work any more ;)
- Groovy interface at this time cannot have default method. You cannot create interfaces in Groovy as Groovy needs to evelve. Groovy can use Java interface with default methods.
- Groovy has traits, give stateability.
- Why default methods in interfaces? Without it, you will be writing utilities.
- Nice to Use, easy to Abuse them ;)
- Be willing to use, not to abuse ;)
- String::toUppercase // is method reference
- IntelliJ IDEA: There are two kinds of programmers, those who have IDEA and those who don’t have IDEA ;)
- Method references is Venkat’s most favorite in Java 8
- Two types of methods: intermediate operation, terminal operation
println “collecting $it”
it * 2}.findAll {
println “picking $it”
it > 6}.inject(0) {c, e-> c + e } //
Java 8 filter is like groovy find on collection
reduce is a terminal operation, mapand filter are intermediate operations.
Lazy in Java is Efficient ;)
Lambda expression function component in Groovy is very inefficient. In Java 8, it is extremely efficient.
- Infinite Stream - you can create a collection that is infinite in length. Lambdas give lazy evaluation, so you can postpone.
Stream.iterate(1, e -> e + 1)
.limit(10) //without this it runs forever ;)
.collect(toList())); //infinite stream of 1,2,3,4….
- in Groovy you can use GPers to do this
- in Java 8, stream() to parallelStream() //concurrent
- try { Thread.sleep(1000);} catch(Exception e) {} //add delay
- InvokeDynamic: One of the most exciting features of Java 8
- means look the other way. Started as a way to support dynamic languages in Java 7.
- Java introduced anonymous inner classes in 1999, when people were crying for lambdas…
- compile a class with inner class, compile take a look at the .class….buy one, get one free ;) it’s not inner class ;)
- It is this feature that made java 8 made performing better
- InvokeDynamic: method binding happens at run time. It is just a binding to the method. Doesn’t incur creating the object (anonymous or what so ever), doesn’t involve object creation, so fast. Happens at the bytecode level.
- When code is compiled, lambda expression calls become InvokeDynamic
Traits are more powerful than default methods. Groovy compiled bytecode with @CompileStatic is not as efficient as Java bytecode in Java 8.
Posts
