Salve a tutti,
sono qua a chiedere aiuto per la soluzione di questo questo che e' l'ultimo esercizio di preparazione per
l'esame di java.
Premetto che il punto 1 e il 2 penso di averlo gia' implementato.

Nei precedenti post ero stato un po' confusionario e non avevo posto il problema in maniera comprensibile quindi allego il testo originale del prof. che e' il seguente:

1. Definire la classe SortedLinkedList che estende la classe LinkedList e che mantiene ordinata la lista:
ridefinire il metodo add() affinché inserisca gli elementi in ordine.
Gli oggetti da inserire devono essere confrontabili e quindi devono implementare l’interfaccia Comparable.
Si ordini la lista in modo che il valore massimo sia in testa (first) e il valore minimo in coda (last).
Verificare la correttezza dell’implementazione: per esempio usando sequenze di stringhe in ordine, in ordine inverso,
casuali, uguali. Verificare con sequenze di 21 elementi Integer casuali, con valori compresi nell’intervallo [-30,30].

2. Sviluppare una classe Process che descriva un processo. Definire tre campi: un intero che
identifica il processo (pid), una stringa per il nome del processo e un intero per
l’occupazione di memoria. Definire il costruttore della classe e il metodo toString().
Implementare l’interfaccia Comparable: il confronto è fatto sulla memoria utilizzata.

3. Scrivere una classe (che contiene il main()) in cui creare un oggetto di tipo
SortedLinkedList, lista di oggetti Process. La sequenza di processi -in ingresso al sistema- è contenuta nel
file processes.txt: ogni riga contiene i dati di un processo, cioè il pid, il nome e la memoria occupata.
Eseguire le seguenti operazioni:
- Leggere una riga del file ed inserire il processo nella lista.
- Se la quantità di memoria utilizzata da tutti i processi supera un valore di soglia
(100000) eliminare dalla lista il processo che in quel momento occupa più memoria
(utilizzare gli iteratori, oggetti Iterator).
- Salvare su file il numero di processi presenti nel sistema e la quantità di memoria
utilizzata da tutti i processi in ogni istante (-ad ogni lettura di una riga-).
Fare i grafici dell’occupazione di memoria e del numero di processi (in ogni istante).
Commentare.
Valutare il costo computazionale per mantenere la lista ordinata e per eliminare il processo che occupa più memoria.

per chiarezza allego anche la classe SortedLinkedList:


codice:
import java.util.*; 
public class SortedLinkedList extends LinkedList 
{ 
private static int elementi; 
public static void main ( String []args ) 
    { 
       if(args.length > 0) 
          elementi = Integer.parseInt(args[0]); 
       else 
         elementi = 21; 
         System.out.println( "Prova su " + elementi + "elementi." ); 
         SortedLinkedList l = new SortedLinkedList(); 
         // riempi la lista di numeri a caso tra -30 e +30 
          ListIterator it_aggiunta = l.listIterator(); 
   Random generatore=new Random(); 
       for ( int i = 0; i < elementi; i++ ) 
       { 
   int segno=generatore.nextInt(2);// 0 o 1 
   int n=generatore.nextInt(31); 
   if(segno==0) 
   l.add(new Integer(- n )); 
   else 
   l.add(new Integer(n)); 
       } 
       // stampa tutti i valori 
       System.out.println( "Collezione completa:" ); 
       stampaCollezione( l ); 
       } 
    private static void stampaCollezione 
                                   ( Collection c ) 
    { 
       Iterator i = c.iterator(); 
       while ( i.hasNext() ) 
       { 
          System.out.println( i.next() ); 
       } 
    } 
    @Override 
public boolean add(Object o){ 
  Comparable c=(Comparable)o;//bisogna usare il cast a Comparable 
  ListIterator it=listIterator(); 
  Comparable c2=null; 
  if(it.hasNext()) 
   c2=(Comparable)it.next(); 
  else{ 
   it.add(c); 
   return true; 
  } 
  while(it.hasNext() && c2.compareTo(c)>0) //<0 x ordine crescente 
     c2=(Comparable)it.next(); 
  //uscito dal while ho raggiunto la posizione di inserimento perchè il compareTo() non da più <0 
  //ora posso usare per inserire in questa posizione il metodo add di ListIterator ma bisognerebbe 
  //tornare indietro di una posizione per essere sicuri che l'inserimento sia in ordine se il compareTo() >0 
  if(c2.compareTo(c)<0)//>0 x ordine crescente 
  it.previous(); 
  it.add(c); 
  return true; 
} 
} 

Questa e' la classe Processo con la classe EsProcesso col main



Codice:
import java.util.*; 
import java.lang.*; 
import java.io.*; 
import javax.swing.JOptionPane;//utility pannello di dialogo 
class Processo implements Comparable{ 
private int pid; 
private String name; 
private int memoria; 
public Processo(int pid,String name,int mem){ 
  this.pid=pid; 
  this.name=name; 
  memoria=mem; 
} 
public int compareTo(Object o){ 
  Processo p=(Processo)o; 
  return this.memoria-p.memoria;//ordina in base alla quantità di memoria in ordine crescente 
} 
public String toString(){ 
  return ""+pid+" "+name+" "+memoria; 
} 

public int GetMemoria(){ 
   return this.memoria; 
} 
public void RemoveMaggiore(){ 
SortedLinkedList lista=new SortedLinkedList();
Iterator it1=lista.iterator();// in questa riga ho creato un nuovo 
//l'oggetto iterator it1 che agisce sull'oggetto list di sortedlinkedlist (idem come sopra)
    Processo p = (Processo) it1.next(); // ottengo il processo 
   memoria -= p.memoria;   // aggiorno la memoria occupata 
   // rimuovo il processo dalla lista 
} 
}
codice:
public class EsProcesso{ 
public static void main(String[] args) throws IOException 
{ 
  //String nomeFile=JOptionPane.showInputDialog("Digita il nome del file da leggere"); 
//altro modo di input file diretto da codice 
String nomeFile="processes.txt"; 
BufferedReader fileLettura=null; 
SortedLinkedList lista=new SortedLinkedList(); 
try { 
try{ 
  fileLettura = new BufferedReader(new FileReader(nomeFile)); 
  String linea=fileLettura.readLine(); 
  while(linea!=null) { 
   String[] tmp=linea.split("\t"); 
   Processo p=new Processo(Integer.parseInt(tmp[0]),tmp[1],Integer.parseInt(tmp[2]));
   lista.add( p); 
   linea=fileLettura.readLine();//per far girare il ciclo 
  } 
}finally{ fileLettura.close();} 
}catch(FileNotFoundException e) {// gestisco le eccezioni 
  System.out.println("Il file "+nomeFile + " non esiste o non puo' essere aperto"); 
}catch(IOException e) { 
  System.out.println("errore di lettura "+e); 
} 
Iterator it=lista.iterator(); 
while(it.hasNext()) 
System.out.println((Processo)it.next());//cosi puoi vedere tutta la lista 
// e stampare a video
} 
Processo p1= new Processo();// creo nuovo oggetto Processo

// sembra che richieda di implementare il costruttore dell'oggetto
// ma non e' gia' istanziato come public nella classe processo?
// sembra che non riconosca i 2 metodi seguenti

while(p1.GetMemoria()>100000){ //che dovrebbe incrementare il metodo GetMemoria()
   // rimuovi il processo che occupa più memoria 
    p1.RemoveMaggiore();    //che dovrebbe incrementare il metodo RemoveMaggiore()
} 
}
Questo e' uno stralcio del file di testo processes.txt

1 init 272
2 migratio 0
3 ksoftirq 0
4 watchdog 0
5 migratio 0
6 ksoftirq 0
7 watchdog 0
8 events/0 0
9 events/1 0
10 khelper 0
11 kthread 0
14 kacpid 0
104 kblockd/ 0
105 kblockd/ 0
108 khubd 0
162 pdflush 0
163 pdflush 0
165 aio/0 0
164 kswapd0 0
166 aio/1 0
259 kseriod 0
417 ata/0 0
418 ata/1 0
424 scsi_eh_ 0
425 scsi_eh_ 0
446 kjournal 0
999 udevd 240