Devo utilizzare per forza questa lista fatta dal mio prof.!
Ecco il codice:
NODE:
codice:
class Node {
Object info;
Node next; /** Struttura ricorsiva; next è un riferimento ad un oggetto della classe stessa. */
public Node(Object o) {
this(o, null);
}
public Node(Object o, Node n) {
info = o;
next = n;
}
}
LISTNODE:
codice:
public class ListNode implements List {
private Node node; /** Riferimento ad un oggetto di classe Node;
* è il primo nodo della lista.
*/
/** Costruttore della lista vuota */
public ListNode() {
node = null;
}
/** Costruttore che inizializza il primo elemento della lista con l'oggetto
* passato come parametro. Viene istanziato un oggetto di classe Node,
* contenente l'oggetto o.
*/
public ListNode(Object o) {
node = new Node(o);
}
/** Costruttore che inserisce tutti gli elementi della lista l mantenendo
* l'ordine, poi inserisce l'elemento o.
*/
public ListNode(Object o, List l) {
if(l != null) revInsert(l);
insert(o);
}
/** Metodo privato che viene invocato da altri metodi. Legge gli elementi della
* lista l e li inserisce in modo da mantenere l'ordine.
*/
private void revInsert(List l) {
if (!l.isEmpty()) {
revInsert(l.tail());
insert(l.head());
}
}
/** Metodo che mi dice se la lista è vuota. */
public boolean isEmpty() {
return (node == null);
}
/** Metodo che restituisce il primo elemento della lista. */
public Object head() {
if (isEmpty()) return null;
else return node.info;
}
/** Metodo che restituisce l'ultimo elemento della lista. */
public Object last() {
if (isEmpty()) return null;
Node tmp = node;
// Scorre tutti gli elementi della lista.
while (tmp.next != null) tmp = tmp.next;
return tmp.info;
}
/** Metodo che restituisce la lista senza il primo elemento (coda). */
public List tail() {
if (isEmpty()) return null;
else {
// Costruisce una lista nuova.
ListNode tmp = new ListNode();
// Impone che il primo nodo sia il vecchio secondo nodo.
tmp.node = node.next;
return tmp;
}
}
/** Metodo che inserisce un elemento in testa alla lista. */
public void insert(Object o) {
// Costruisce un nuovo nodo con o all'inizio e il vecchio nodo come successivo.
node = new Node(o, node);
}
/** Metodo che cancella un elemento dalla lista: ricerca l'elemento richiesto;
* se viene trovato, i riferimenti vengono cambiati in modo da escludere
* l'elemento da cancellare. Se l'elemento non viene trovato, la lista non cambia.
* In ogni caso il chiamante non viene notificato.
*/
public void remove(Object o) {
if (!isEmpty()) {
Node pred = node;
Node tmp = node.next;
if (node.info.equals(o)) node = node.next;
else
while(tmp != null)
if (tmp.info.equals(o)) {
pred.next = tmp.next;
return;
}
else {
pred = pred.next;
tmp = tmp.next;
}
}
}
/** Metodo che calcola la lunghezza della lista scorrendo tutti gli elementi
* della lista e incrementando di volta in volta un contatore. Versione
* dipendente dall'implementazione.
*/
public int lengthD() {
Node tmp = node;
int cont = 0;
while(tmp != null) {
tmp = tmp.next;
cont++;
}
return cont;
}
/** Metodo che calcola la lunghezza della lista. Versione indipendente dalla
* implementazione.
*/
public int length() {
if (isEmpty()) return 0;
else return (tail().length()+1);
}
/** Metodo che dice se un elemento è nella lista. */
public boolean contains(Object o) {
Node tmp = node;
while (tmp != null) {
if (tmp.info.equals(o)) return true;
tmp = tmp.next;
}
return false;
}
/** Metodo che permette di ottenere una stringa corrispondente alla lista. */
public String toString() {
String tmp = "";
for(Node i=node; i!=null; i=i.next) tmp = tmp + " " + i.info.toString();
return tmp;
}
}
CLIENTEDITTAINDIVIDUALE:
codice:
public class ClienteDittaIndividuale extends ClienteSocieta /*implements Serializable*/ {
private String codFiscale;
public ClienteDittaIndividuale(String c, String n) {
super(c, n);
}
/** Metodo per inserire il codice fiscale. */
public void insCodFiscale(String codice) {
codFiscale = codice;
}
/** Metodo che restituisce il codice fiscale del cliente. */
public String getCodFiscale() {
return codFiscale;
}
/** Ridefinizione del metodo salvaCliente. */
public void salvaCliente(ClienteDittaIndividuale c) {
FileOutputStream f = null;
try {
f = new FileOutputStream("Clienti.dat", true);
}
catch (IOException e) {
System.out.println("Errore 1");
System.exit(1);
}
ObjectOutputStream os = null;
try {
os = new ObjectOutputStream(f);
os.writeObject(c);
os.flush();
os.close();
}
catch (IOException e) {
System.out.println("Errore 2");
System.exit(2);
}
}
/** Ridefinizione di salvaListaClienti */
public void salvaListaClienti(ListNode l) {
ClienteDittaIndividuale primo, ultimo;
primo = (ClienteDittaIndividuale)l.head();
ultimo = (ClienteDittaIndividuale)l.last();
if (l.isEmpty()) return;
if (primo.equals(ultimo)) {
salvaCliente(primo);
return;
}
else {
salvaCliente(primo);
salvaListaClienti((ListNode)l.tail());
}
}
/** Ridefinizione del metodo leggiCliente. */
public void leggiCliente(int lunghezza) {
FileInputStream fis = null;
ObjectInputStream is = null;
try {
fis = new FileInputStream("Clienti.dat");
is = new ObjectInputStream(fis);
}
catch (IOException e) {
System.out.println("Errore 3");
e.printStackTrace();
System.exit(3);
}
ClienteDittaIndividuale c2 = null;
try {
int i=0;
while (i<lunghezza) {
c2 = (ClienteDittaIndividuale)(is.readObject());
System.out.println(c2.getNome());
i++;
}
is.close();
}
catch (IOException e) {
System.out.println("Errore 4");
e.printStackTrace();
System.exit(4);
}
catch (ClassNotFoundException e) {
System.out.println("Errore 5");
e.printStackTrace();
System.exit(5);
}
}
/** Ridefinizione del metodo getNomiClienti(). */
public String[] getNomiClienti(ListNode l) {
int lunghezza = l.length();
String[] nomi = new String[lunghezza];
for(int i=0; i<lunghezza; i++) {
ClienteDittaIndividuale c = (ClienteDittaIndividuale)l.head();
String n = c.getNome();
nomi[i] = n;
l = (ListNode)l.tail();
}
return nomi;
}
}
GRAZIE MILLE!
Rispondi quotando
VVoVe: 
