• La classe Node ha due tipi di costruttore, uno senza parametri ed uno con parametri. Quest'ultimo consente la creazione con inizializzazione del cargo e del puntatore al nodo successivo.
• C'è un metodo toString che converte il cargo in una stringa stampabile ogni volta che viene invocata la funzione print sul nodo.

       
void setup() {
  Node node3 = new Node (3, null);
  Node node2 = new Node (2, node3);
  Node node1 = new Node (1, node2); 
  printList(node1);
}

void printList (Node list) {
    Node node = list;
    
    while (node != null) {
        print(node);
        node = node.next;
    }
    println();
}

class Node {
  int cargo;
  Node next;
  
  Node() {
    cargo = 0;
    next = null;
  }
  
  Node (int cargo, Node next) {
    this.cargo = cargo;
    this.next = next;
  }
  
  String toString() { //rende l'oggetto di classe Node stampabile
    return cargo + " ";
  }
}

import java.util.*;

IntList lista;
Stack pila;

void setup() {
  pila = new Stack();
  lista = new IntList();
  lista.addFirst(3);
  lista.addFirst(2);
  lista.addFirst(1);
  lista.printList();
  for (Node node = lista.head; node != null; node = node.next) {
   pila.push(node); 
  }
  while (!pila.isEmpty()) {
    Node node = (Node) pila.pop();
    print(node);
  }
}

class IntList {
 ... omissis ...
 
class Node {
 ... omissis ... 


	  

• gli elementi della lista sono inseriti nella pila nel loro ordine naturale, essendo così estraibili da questa in ordine inverso,
• esiste un metodo isEmpty() della classe Stack che consente di verificare la condizione di pila vuota,
• è necessario fare un type casting sull'oggetto restituito dalla pop(). Questo è un generico Object in quanto la classe Stack non è in grado di conoscere il tipo dei suoi elementi.
• in generale è sempre possibile convertire un algoritmo ricorsivo in uno non ricorsivo facendo uso di uno stack. In questo esempio la pila viene usata in luogo del run-time stack.

Queue q;
Integer uno = new Integer(1);
Integer due = new Integer(2);
Integer tre = new Integer(3);

void setup() {
  q = new Queue();
  q.add(uno);
  q.add(due);
  q.add(tre);
  println(q.remove());
  println(q.remove());
  println(q.remove());
}

class Queue {
 int length;
 Node first, last;

   Queue() {
     length = 0;
     first = null;
     last = null;
   }
   
   boolean isEmpty() {
     return first == null;
   }

   void add (Object obj) {
     Node node = new Node(obj, null);
     if (last != null) {
       last.next = node;
     }
     last = node;
     if (first == null) {
       first = last;
     }
     length +=1;
   }
   
   Object remove () {
     Node result = first;
     if (first != null) {
       first = first.next;
     }
     else {
       last = null;
     }
     length -= 1;
     return result;
   }
 }
 


class Node {
  Object cargo;
  Node next;
  
  Node() {
    cargo = null;
    next = null;
  }
  
  Node (Object cargo, Node next) {
    this.cargo = cargo;
    this.next = next;
  }
  
  String toString() { //rende l'oggetto di classe Node stampabile
    return cargo + " ";
  }
}