public class TxtImporterJavaImpl implements Importer<Person> {

    private final String fileName;

    public TxtImporterJavaImpl(String fileName) {
        this.fileName = fileName;
    }

    private static SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");

    public List<Person> executeImport() {
        List<Person> l = new ArrayList<Person>();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(fileName));
            String line = reader.readLine();
            while (line != null) {
                String[] split = line.split("\\|");
                Person p = new PersonJavaImpl();
                p.setName(split[0]);
                p.setSurname(split[1]);
                p.setBirthDate(format.parse(split[2]));
                Address address = new AddressJavaImpl();
                address.setStreet(split[3]);
                address.setCity(split[4]);
                p.setAddress(address);
                l.add(p);

                line = reader.readLine();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return l;
    }
}

Exceptions are managed with runtime exceptions for simplicity, despite this error handling is not trivial. By analyzing the executeImport method we can note that a part of it deals with text file reading while another part performs the conversion from a file row to an object. So we can create a class that encapsulates the file reading code to be reused in other similar contexts

public class GenericTxtImporterJavaImpl<T> implements Importer<T> {

    private final String fileName;
    private final RowImporter<T> rowImporter;

    public GenericTxtImporterJavaImpl(String fileName, RowImporter<T> rowImporter) {
        this.fileName = fileName;
        this.rowImporter = rowImporter;
    }

    public List<T> executeImport() {
        List<T> l = new ArrayList<T>();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(fileName));
            String line = reader.readLine();
            while (line != null) {
                l.add(rowImporter.executeImport(line));
                line = reader.readLine();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (reader != null) {
                try {
                &nbsp;   reader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return l;
    }
}

public interface RowImporter<T> {
    T executeImport(String s);
}

and an implementation that create a Person object starting from a row:

public class PersonImporter implements RowImporter<Person> {

    private static SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");

    public Person executeImport(String s) {
        try {
            String[] split = s.split("\\|");
            Person p = new PersonJavaImpl();
            p.setName(split[0]);
            p.setSurname(split[1]);
            p.setBirthDate(format.parse(split[2]));
            Address address = new AddressJavaImpl();
            address.setStreet(split[3]);
            address.setCity(split[4]);
            p.setAddress(address);
            return p;
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

The interesting part of PersonImporter is the executeImport method. GenericTxtImporterJavaImpl needs to know which method must be invoked to transform a file row into an object. Thus RowImporter is used only for wrapping the method to pass. This situation is very frequent in java (for example in event listeners), and anonymous inner classes were introduced in order to write shorter implementations. For example we can use GenericTxtImporterJavaImpl without explicitly define an implementation of RowImporter:

List<Person> l = new GenericTxtImporterJavaImpl<Person>(
    "resources/people.txt",
    new RowImporter<Person>() {

        public Person executeImport(String s) {
                Person p = new PersonJavaImpl();
                //....
                return p;
        }
    }
).executeImport();

Using anonymous classes provides amore compac t but less readable code, especially for inexperienced developers.
The Groovy version of the Importer implementation is:

class TxtImporterGroovyImpl implements Importer<Person> {
   
    String fileName

    private static SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy")
   
    List<Person> executeImport() {
        List<Person> l = new ArrayList<Person>()
        new File(fileName).eachLine {
            String[] split = it.split("\\|")
            Person p = new PersonGroovyImpl()
            p.name = split[0]
            p.surname = split[1]
            p.birthDate = format.parse(split[2])
            Address address = new AddressGroovyImpl()
            address.street = split[3]
            address.city = split[4]
            p.address = address
            l.add(p)
        }
        return l
    }
}

def map = [ 'a', 7, 'b', new Date(), new Date() + 1 ].groupBy{ it.class }

map.eachWithIndex { e, index ->
    println "${index} Classe ${e.key} valori ${e.value}"
}

This code uses two closure (the second with an explicit parameter definition) and two methods of Map and List that accept a closure as input. Groovy defines many useful methods on collection that uses closures, for example each, collect, find, findAll, min, max. The groupBy method iterate on list items and brings together the elements based on the closure return value, in a method or a closure the keyword return may be omitted because it returned the evaluation of last command. The eachWithIndex method iterate on collection's items and passes each element and its iteration index to the closure. The instruction inside the closure uses GString, using the syntax ${variableName} you can easily create strings containing values of available variables.
Let's see how to implement a Groovy class that exports a list of people in a xml file. The corresponding java example should use dom or external libraries like jdom, jaxb or castor. This is the Groovy implementation:

class XmlExporterGroovyImpl implements Exporter {
   
    private String fileName
   
    XmlExporterGroovyImpl(String fileName) {
        this.fileName = fileName
    }
   
    private SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy");
   
    void executeExport(List<Person> people) {
        def writer = new FileWriter(fileName);
        MarkupBuilder builder = new MarkupBuilder(writer)
       
        try {
            builder.people(total: people.size()) {
                people.eachWithIndex { p, pos ->
                    builder.person(index: pos) {
                        name(p.name)
                        surname(p.surname)
                        birthDate(formatter.format(p.birthDate))
                        address {
                            street(p.address.street)
                            city(p.address.city)
                        }
                    }
                }
            }
        }
        finally {
            if (writer != null) {
                writer.close();
            }
        }
    }
}

This class uses Groovy builder, a concept a bit particular but very useful. In practice you can invoke on the builder object methods with name corresponding to the name of the xml element you want to create. These methods are not normally defined, calls are intercepted and xml code is created automatically according to the name of the method and to the method parameters. If a pair is passed to the method an attribute is added to the xml tree, if a single value is passed then it is inserted inside the xml element.

public class MainJava {

    public static void main(String[] args) {
        List<Person> people = new TxtImporterJavaImpl("resources/people.txt").executeImport();
        new XmlExporterGroovyImpl("resources/people.xml").executeExport(people);
    }
}

The main method calls methods of java classes and methods of Groovy classes, even the list of people imported by a java method is passed to a Groovy method that exports that list in xml. Groovy can also be used as a scripting language, so we can define code outside of class, for example:

package groovytutorial.groovyimpl

def dir = "resources"

def people = new TxtImporterGroovyImpl(fileName: "${dir}/people.txt").executeImport()
new XmlExporterGroovyImpl("${dir}/people.xml").executeExport(people)

In this code are also used not typed variables that can be defined with the keyword def (similar to var in JavaScript). On the Internet there are dissenting opinions about the use of variables not typed in Groovy, it depends on personal experience, probably a java developer will be much more at ease using typed variables.