Java - Simple method faster than design pattern?

So i have the Main.class

public class Main {
    public static void main(String[] args) {

        NodoLista<Integer> nodoLista = new NodoLista<Integer>(1);
        nodoLista.app(2);
        nodoLista.app(3);
        nodoLista.app(4);
        nodoLista.app(5);

        long startTime, endTime;

        startTime = System.nanoTime();
        System.out.println(nodoLista.list());
        endTime = System.nanoTime();
        System.out.format("%.2f miliseconds elapsed.\n", (endTime - startTime) * 1.0 );

        startTime = System.nanoTime();
        System.out.println(nodoLista.list2());
        endTime = System.nanoTime();
        System.out.format("%.2f miliseconds elapsed.\n", (endTime - startTime) * 1.0 );

    }

    public Main() {
        super();
    }

}

My NodoLista class:

public class NodoLista<T> {

    private T value;

    private NodoLista<T> siguiente;
    private EstadoSiguiente<T> estadoSiguiente;

    // Getters and Setters

    public NodoLista(T value) {
        this.value = value;
        this.estadoSiguiente = new EstadoSinSiguiente<T>(this);
    }

    public void app(T valor) {
        estadoSiguiente.setSiguiente(valor);
    }

    public ArrayList<T> list() {
        return estadoSiguiente.list();
    }

    public ArrayList<T> list2() {
        ArrayList<T> subList = new ArrayList<T>();
        subList.add(getValue());
        NodoLista<T> actual = getSiguiente();
        while (actual != null) {
            subList.add(actual.getValue());
            actual = actual.getSiguiente();
        }
        return subList;
    }
}

And my state pattern for the next node that i called siguiente:

public interface EstadoSiguiente<T> {

    void setSiguiente(T valor);

    ArrayList<T> list();

}

public class EstadoConSiguiente<T> implements EstadoSiguiente<T> {

    public NodoLista<T> nodo;

    @Override
    public void setSiguiente(T valor) {
        nodo.getSiguiente().app(valor);
    }

    @Override
    public ArrayList<T> list() {
        ArrayList<T> subList = new ArrayList<T>();
        subList.add(nodo.getValue());
        subList.addAll(nodo.getSiguiente().list());
        return subList;
    }

}

public class EstadoSinSiguiente<T> implements EstadoSiguiente<T> {

    public NodoLista<T> nodo;

    @Override
    public void setSiguiente(T valor) {
        nodo.setSiguiente(new NodoLista<T>(valor));
        nodo.setEstadoSiguiente(new EstadoConSiguiente<T>(nodo));
    }

    @Override
    public ArrayList<T> list() {
        ArrayList<T> subList = new ArrayList<T>();
        subList.add(nodo.getValue());
        return subList;
    }

}

Basicly, y have two functions that do the same, list() return a list of elements of te linked list recursively, list2() return exactly the same, procedurally.

I notice that the procedural method just is faster than recursive, not substantially, but,why do this happen? Are messages between classes slower than a block of code, In this case?