eliminazione record con iteratori

[aduri]

Dovrei caricare il file composto da record ognuno dei quali composto di 3 campi di cui l'ultimo e' la dimensione della memoria.
La richiesta e' caricare il file, ordinarlo per dimensione memoria in ordine crescente e quando si raggiungono 100000 di somma di memoria occupata il processo che ha maggiore occupazione di memoria va eliminato.
Il programma compila fino all'ordinamento della lista in ordine crescente e mi da errore quando carico la classe ScanDeleteLast che dovrebbe rimuovere con gli iteratori (come richiesto dal prof.) l'ultimo record.
Non ho ancora implementato il controllo sulla somma di memoria.
Qualcuno mi puo' dare una dritta?
ecco il codice

A presto


import java.util.*;
import java.io.*;
import javax.swing.JOptionPane;//utility pannello di dialogo

class MyFile {
public int memoria;
public int pid;
public String nome;

MyFile (String linea)
{
String aTmp[] = linea.split("\t");
this.memoria = Integer.parseInt(aTmp[2]);
this.nome = aTmp[1];
this.pid = Integer.parseInt(aTmp[0]);
}

MyFile (int memoria, String nome)
{
this.pid = pid;
this.memoria = memoria;
this.nome = nome;
}

public static void main(String[] args) throws IOException
{
Keymemoria keymemoria = new Keymemoria();
// KeyNome keyNome = new KeyNome();
Vector v = new Vector();// creo Vector (array dinamico)
// Carico file da processes.txt
//String nomeFile=JOptionPane.showInputDialog("Digita il nome del file da leggere");
String nomeFile="processes.txt"; //altro modo di input file diretto da codice

BufferedReader fileLettura;

try {
fileLettura = new BufferedReader(new FileReader(nomeFile));
while(true) {
String linea = fileLettura.readLine();
if(linea==null) {
break;
} else {
v.add( new MyFile(linea) );
}
}
} 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);
}

MyFile[] a = new MyFile[v.size()];
for( int i = 0; i < v.size(); i++ ) {
a[i] = (MyFile)v.get(i);
}
System.out.println ("------------------");
System.out.println ("Array non ordinato: ");
System.out.println ("pid nome memoria");
for (int k = 0; k < a.length; k++) {
System.out.println (a[k].pid + " " + a[k].nome+ " " + a[k].memoria);

}
System.out.println ("------------------");
System.out.println ("Array ordinato rispetto alla dimensione della memoria: ");
System.out.println ("pid nome memoria");
Arrays.sort (a, keymemoria);
for (int k = 0; k < a.length; k++) {
System.out.println (a[k].pid + " " + a[k].nome+ " " + a[k].memoria);

}
System.out.println ("------------------");
//Implemento la ricerca binaria per dimensione
System.out.println ("");

}
}

class Keymemoria implements Comparator {
public int compare (Object MyFile1, Object MyFile2)
{
int memoria1 = ((MyFile) MyFile1).memoria;
int memoria2 = ((MyFile) MyFile2).memoria;
return (memoria1 < memoria2 ? -1 : (memoria1 == memoria2 ? 0 : 1));
}
}

public class ScanDeleteLast {
SortedLinkedList l = new SortedLinkedList();
ListIterator it = l.listIterator();
for ( int i = 0; i < l.lenght; i++ )
{
while(it.hasNext()) {
String item = (String) l.next();
}
// toglie l’ultimo elemento traversato
it.remove(); // rimuove record con memoria maggiore

}
}

[aduri]

Ho rivoluzionato il codice pero'
ho problemi ad approcciare la soluzione dell'eliminazione del record .

Ho creato una classe EsProcess che legge i record simili a processes e li ordina in modo decrescente.
Questo mi complica la vita perche' nell'altro caso con un controllo con
while(it.hasNext() raggiungevo il fondo della lista e rimuovevo.
In questo caso col record con memoria piu' grande in cima alla lista diventa piu' complicato.
Per cio' che riguarda la somma della memoria preferirei non inquinare la classe sortedlinkedlist (inserendo una variabile che conti la memoria) e
creare un metodo sumMem all'interno di EsProcess ma ho difficolta' ad implementarlo.
La classe SortedLinkedList l'avevo gia' implementata precedentemente e l'allego:

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;
}
}




il codice che ho implementato per l'ultimo esercizio e':

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 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]));//mi ero dimenticato io
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
}
}


Scusate per la lungaggine

[aduri]

Il problema dell'iterator alla fine e' una banalita' in quanto facendo it.next() una volta istanziato l'oggetto iterator it vado proprio sul primo record e lo posso cosi' rimuovere con it.remove().
Il problema e' creare un metodo che mi sommi la memoria dell'oggetto p e che controlli di non aver superato 100000 ed a questi punti dovrei creare un nuovo ogetto iterator it1 fare it1.next() (per tornare in cima alla lista) e poi it1.remove().

Ho provato a creare un metodo subito dopo il compareTo(Object o)
public int sumMem(Object o){
Processo p=(Processo)o;
return p.memoria;//ritorna il valore della memoria del record


e dopo aver istanziato l'oggetto iteratore it

it.next();
int a = p.memoria;
System.out.println("valore memoria"+a);

ma non compila da errore in p.memoria. :doh:

Dove sbaglio??

Ancora un po' di pazienza
Grazie

[lovaz]

Beh, memoria e' un campo privato, non ci puoi accedere dall'esterno dell'oggetto.

[aduri]

Quindi basterebbe scrivere:

public int sumMem(Object o){
Processo p=(Processo)o;
int a= p.memoria;
return a;;//ritorna il valore della memoria del record

e nel corpo del main()

it.next();
int a = p.memoria;
System.out.println("valore memoria"+a);

:rolleyes:
grazie

[aduri]

Non sono ancora riuscito a schiodarmi;
ho problemi a richiamare i metodi GetMemoria() e RemoveMaggiore().


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
}


}

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()
}
}

Scusate la lunghezza.

Saluti e grazie per l'aiuto

[lovaz]

Intanto devi dire esattamente che errori ti dà, cosa vuol dire
"ho problemi a richiamare i metodi ..."?

Poi dovresti postare il codice indentato, è molto fastidioso leggerlo cosi'.

Inoltre, se usi java 5, puoi usare il nuovo for e i generics, ti assicuro che il codice
si semplifica molto, rispetto all'uso degli iteratori.

[aduri]

Grazie della risposta,
Allego il codice indentato.
L'ho un po' modificato.
Ho anche inserito un costruttore senza parametri della classe Processo.

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() { //costruttore senza parametri d'ingresso
this.pid=0;
this.name=null;
memoria=0;
}
public Processo(int pid,String name,int mem){ // costruttore con parametri
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 int GetMemoria(){
SortedLinkedList lista=new SortedLinkedList();// l'avevo gia' creato nel main
// nella classe Processo compila ma mi sembra una assurdita'
return this.memoria;
}

public void RemoveMaggiore(){
SortedLinkedList lista=new SortedLinkedList();// l'avevo gia' creato nel main creandolo anche
Iterator it_remove=lista.iterator();// in questa riga ho creato
//l'oggetto iterator it_remove che agisce sull'oggetto list di sortedlinkedlist (idem come sopra)
Processo p = (Processo) it_remove.next(); // ottengo il processo
memoria -= p.memoria; // aggiorno la memoria occupata
//e rimuovo il processo dalla lista
}

public String toString(){
return ""+pid+" "+name+" "+memoria;
}
} //chiudo la classe processo


public class EsProcesso{ // classe col main
public static void main(String[] args) throws IOException
{
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");
// convertiamo le stringhe in intero con parseInt e valueOf x il contrario
Processo p=new Processo(Integer.parseInt(tmp[0]),tmp[1],Integer.parseInt(tmp[2]));//mi ero dimenticato io
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 it1=lista.iterator();
while(it1.hasNext()) // fino a che trova un elemento stampa i record
System.out.println((Processo)it1.next());//e cosi puoi vedere tutta la lista

Iterator it2=lista.iterator(); // creo nuovo iteratore e analizzo lista
while(it2.hasNext())
if(lista.GetMemoria()>100000){
//
// rimuovi il processo che occupa più memoria
lista.RemoveMaggiore();
}
}

}

Nel secondo messaggio del post avevo allegato il codice della classe sortedlikedlist.

Riguardo l'uso delle innovazioni, in questa occasione non posso in quanto sto svolgendo un esercizio legato ad un
esame all'universita' della facolta' di ing. elettronica che sto affrontando da lavoratore senza frequentare.
Come avrete notato ho parecchie lacune.

Riguardo l'errore no vede il metodo GetMemoria() legato alla lista; allego il log (io uso Jcreator):

C:\Documents and Settings\aduri\Desktop\SW Java ok\esame\EsProcesso.java:79: cannot find symbol
symbol : method GetMemoria()
location: class SortedLinkedList
if(lista.GetMemoria()>100000){
^
C:\Documents and Settings\aduri\Desktop\SW Java ok\esame\EsProcesso.java:82: cannot find symbol
symbol : method RemoveMaggiore()
location: class SortedLinkedList
lista.RemoveMaggiore();
^
2 errors

Process completed.

[lovaz]

Non deve essere facile frequentare l'università da lavoratore, complimenti...

Ma GetMemoria() e RemoveMaggiore() -
che tra l'altro andrebbero con la prima lettera minuscola secondo le
convenzioni di java -
sono metodi di Processo, non di SortedLinkedList, quindi non li puoi chiamare
con lista.GetMemoria()...

Ora non ho tempo per guardare più a fondo il codice.

Comunque se hai un paio d'ore da perdere potresti leggere
la mia guida su java, non è molto lunga:
http://www.hwupgrade.it/forum/showthread.php?t=1271794

Se non altro ti darà un po' di "impostazione".

[aduri]

Finalmente sono riuscito con un aiuto di un amico ad implementare la parte del codice di controllo e rimozione processi. :D
Ora mi manca solo di stampare i processi rimasti in un file processes1.txt.
Mi e' chiaro il processo di lettura ma ho problemi con quello di scrittura.
Ho creato un oggetto fileScrittura che ho incapsulato in un buffer dopo di che .......... :mc: sto facendo un po' di caos qualcuno mi puo' dare un chiarimento.

Il codice e' stato commentato.

Grazie


import java.util.*;
import java.lang.*;
import java.io.*;


class Processo implements Comparable{
private int pid;
private String name;
private int memoria;

public Processo(int pid,String name,int mem){ // costruttore
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 int getMemoria(){
return this.memoria;
}
public String toString(){
return ""+pid+" "+name+" "+memoria;
}
} //chiudo la classe processo


public class EsProcesso
{ // classe col main
public static void main(String[] args) throws IOException
{
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");
// convertiamo le stringhe in intero con parseInt e valueOf x il contrario
Processo p=new Processo(Integer.parseInt(tmp[0]),tmp[1],Integer.parseInt(tmp[2]));//mi ero dimenticato io
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 it1=lista.iterator();

while(it1.hasNext()) // fino a che trova un elemento stampa i record
{
Processo proc = (Processo)it1.next();
System.out.println(proc.toString());//e cosi puoi vedere tutta la lista
}

// codice analisi memoria
while(true)
{
Iterator iter = lista.iterator();
int memtot = 0;
while(iter.hasNext())
{
Processo proc = (Processo)iter.next();
memtot += proc.getMemoria();
}
if(memtot >= 100000)
{
System.out.print("Limite di memoria raggiunto, ");
//elimina il processo più grande che è nella prima posizione della lista
iter = lista.iterator();
Processo proc = (Processo)iter.next();
System.out.println("elimino il processo:\n"+proc.toString());
iter.remove();
}
else
break;
}

// String nomeFile1="processes1.txt";
//
// BufferedWriter fileScrittura=null;
// SortedLinkedList lista1=new SortedLinkedList();
// try {
// try{
// // Creo un oggetto che incapsulo in un buffer
// fileScrittura = new BufferedWriter(new FileWriter(nomeFile1));
//
// String linea1=fileScrittura.readLine();
// while(linea1!=null) {
// String[] tmp=linea.split("\t");
// // convertiamo le stringhe in intero con parseInt e valueOf x il contrario
// Processo p1=new Processo(Integer.parseInt(tmp[0]),tmp[1],Integer.parseInt(tmp[2]));//mi ero dimenticato io
// lista.add( p1);
// linea1=fileScrittura.readLine();//per far girare il ciclo
// }
// }finally{ fileScrittura.close();}
// } catch(IOException e) {
// System.out.println("errore di scrittura "+e);
// }
}
}

Ottimo tutorial!!! :D

[aduri]

Ho rivoluzionato l'ultima parte che era un caos tremendo:eek:
e sono riuscito a far salvare la lista nel file processes1.txt ma senza tabulazione.
Ho cercato di usare il metodo split senza successo.
Qualcuno puo' darmi l'ultimo aiutino?

Grazie

Allego il codice:

import java.util.*;
import java.lang.*;
import java.io.*;


class Processo implements Comparable{
private int pid;
private String name;
private int memoria;

public Processo(int pid,String name,int mem){ // costruttore
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 int getMemoria(){
return this.memoria;
}
public String toString(){
return ""+pid+" "+name+" "+memoria;
}
} //chiudo la classe processo


public class EsProcesso
{ // classe col main
public static void main(String[] args) throws IOException
{
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");
// convertiamo le stringhe in intero con parseInt e valueOf x il contrario
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 it1=lista.iterator();

while(it1.hasNext()) // fino a che trova un elemento stampa i record
{
Processo proc = (Processo)it1.next();
System.out.println(proc.toString());//e cosi puoi vedere tutta la lista
}

// codice analisi memoria
while(true)
{
Iterator iter = lista.iterator();
int memtot = 0;
while(iter.hasNext())
{
Processo proc = (Processo)iter.next();
memtot += proc.getMemoria();
}
if(memtot >= 100000)
{
System.out.print("Limite di memoria raggiunto, ");
//elimina il processo più grande che è nella prima posizione della lista
iter = lista.iterator();
Processo proc = (Processo)iter.next();
System.out.println("elimino il processo:\n"+proc.toString());
iter.remove();
}
else
break;
}

// apertura del file per la scrittura
FileWriter f = new FileWriter("processes1.txt");
// creazione dell'oggetto per la scrittura
PrintWriter out = new PrintWriter(f);
// scrittura del testo su file

out.println(lista);

// chiusura del file
out.close(); }

}

[aduri]

Risolto!!!

Grazie a tutti