Java8_to.groovy

// === Setup to make the code runnable ===

@Grab( 'com.bloidonia:groovy-stream:0.6.2' )
@Grab( 'org.codehaus.gpars:gpars:1.1.0' )

import groovy.transform.Immutable
import groovy.stream.Stream
import groovyx.gpars.GParsPool

def file = new File('persons.csv')
file.delete() // to reset from last time
file.createNewFile() 
file << '''name, age, city, country
Ivar Østhus, 28, Sandnes, Norway
Theo, 13, Skedsmo, Norway
Viswanathan Anand, 43, Mayiladuthurai, India
Magnus Carlsen, 22, Tønsberg, Norway
'''

@Immutable class Person { String name; int age; String city; String country }

def persons = [ 
    new Person("Ivar", 28, "Sandnes", "Norge"), 
    new Person("Theo", 13, "Skedsmo", "Norge"), 
    new Person("Kjetil", 40, "Skedsmo", "Norge")
]

// =======JAVA in comments, Groovy is runnable=======

// Arrays.asList(1,2,3,4,5).forEach(System.out::println)

(1..5).each { println it }

//  Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(n -> n % 2 == 0).mapToInt(n -> n * 2).sum()

Stream.from(1..6).filter { it % 2 == 0 }.sum()

// persons.stream().filter(p -> p.getAge() > 17)

Stream.from(persons).filter { it.age > 17 }

// persons.stream().filter(p -> p.getAge() > 17).sorted((p1, p2) -> p1.getAge() - p2.getAge());

Stream.from(persons).filter { it.age > 17 }.sort{ it.age }

// persons.stream().filter(p -> p.getCity().equals("Sandnes")).mapToInt(p -> p.getAge()).average();

[Stream.from(persons).filter{ it.city =="Sandnes" }*.age].collect{ it.sum() / it.size() }[0]

// persons.stream().map(Person::getName).collect(toSet())

Stream.from(persons)*.name.toSet()

// persons.stream().collect(groupingBy(Person::getAge, mapping(Person::getName, toList()))

Stream.from(persons.groupBy { it.age }).map { [(it.key) : it.value*.name ] }

// public static Function<String, Person> toPerson = (line) -> {
//     String[] p = line.split(", ");
//     return new Person(p[0], Integer.parseInt(p[1]), p[2], p[3]);
// };

def toPerson = { line -> 
    def p = line.split(", "); 
    new Person(p[0], p[1].toInteger(), p[2], p[3]) 
}

// public static Predicate<Person> isAdult = p -> p.getAge() > 17;

def isAdult = { it.age > 17 }

// InputStream is = new FileInputStream(new File("persons.csv"));
// BufferedReader br = new BufferedReader(new InputStreamReader(is));

// List<Person> persons = br.lines()
//     .substream(1)
//     .map(toPerson)
//     .filter(isAdult)
//     .limit(50)
//     .collect(toList());

persons = Stream.from(new File('persons.csv').readLines()
    .drop(1))
    .map(toPerson)
    .filter(isAdult)
    .take(50)
    .toList()
    
// OptionalDouble average = persons.parallelStream().filter(p -> p.getCity().equals("Sandnes")).mapToInt(p -> p.getAge()).average();

GParsPool.withPool {
   [persons.parallel.filter{ it.city =="Sandnes" }.map {it.age}.getCollection()].collect {it.sum() / it.size() }[0]
}

Men til slutt må man huske på at syntax ikke er alt, det er bare sukkeret på toppen som gjør det extra sweet.