[JAVA] - argomenti del MAIN

[FrankieB76]

Buonasera,
volevo chiedere una informazione su una questione, credo, abbastanza semplice.
Ho scritto un programma che deve eseguire le stesse operazioni, ma su esempi diversi, e per fare ciò accede a file diversi che ho caricato nel programma (sto usando Eclipse)

Faccio prima se metto l'esempio pratico che a spiegarlo a parole.

Inizialmente richiamavo un metodo con un file:

metodo_a (esempio1file_a.txt)
metodo_b (esempio1file_b.txt)
metodo_c (esempio1file_c.txt)

ora, una volta verificato il programma con questo esempio 1, se dovevo andare a verificarlo con un secondo esempio, dovevo andare sul programma a cambiare i richiami ai files in tutte le occorrenze:

metodo_a ("esempio2file_a.txt")
metodo_b ("esempio2file_b.txt")
metodo_c ("esempio2file_c.txt")

Inizialmente ho migliorato mettendo file di diversi esempi con lo stesso nome in cartelle diverse, passando così a dover scrivere una cosa di questo tipo:

metodo_a ("data1/file_a.txt)
metodo_b ("data1/file_b.txt)
metodo_c ("data1/file_c.txt)

Così facendo bastava per 10 esempi mettere sempre i nomi degli stessi files, ma dovevo sempre cambiare il nome della cartella.

Mi hanno detto (non come però...) che invece è possibile migliorare ancora lavorando sulla dichiarazione del Main:

public static void main(String[] args)

e lavorando su quell' "args", potrei definire in quel punto il nome della cartella dove ci sono i files che mi servono di volta in volta, e cosi cambiare una sola cosa alla volta e non una per ognuna delle chiamate che devo fare.

come faccio ad indicare la cartella giusta nella dichiarazione del main?

grazie mille a chiunque voglia collaborare!

[GByTe87]

Dunque; per eseguire il programma, una volta finiti gli sviluppi userai una sintassi del genere:

java Main

A questo punto puoi fare una cosa del genere:

java Main file1.txt dir/file2.txt dir2/file3.txt

L'array di stringhe args conterrà tutti i parametri che seguono il file *.class in esecuzione. Banalmente, eseguendo ciò..

public class Main{
    public static void main(String[] args) {
        for (String e : args)
            System.out.println(e);
    }
}

...in questo modo..

java Main file1.txt dir/file2.txt dir2/file3.txt

Il risultato a console sarà..

file1.txt 
dir/file2.txt 
dir2/file3.txt

A quel punto diventa uno scherzo:

public class Main{
    public static void main(String[] args) {
        for (String e : args) {
            metodo_a(e);
            metodo_b(e);
            metodo_c(e);
        }
    }
}

Scusa se non sono stato chiarissimo ma sono un po' di fretta.

(In Eclipse, per aggiungere parametri click col destro sul progetto -> Run -> Run Configurations)

[FrankieB76]

ehmm... prima di tutto ti ringrazio della risposta.

però non è che abbia capito proprio tutto quello che mi hai scritto.

nel dettaglio, cosa fa esattamente quello che hai scritto tu? in particolare cosa fanno questo:

public class Main{
    public static void main(String[] args) {
        for (String e : args)
            System.out.println(e);
    }
}

e quest'altro?

public class Main{
    public static void main(String[] args) {
        for (String e : args) {
            metodo_a(e);
            metodo_b(e);
            metodo_c(e);
        }
    }
}

a vedere il for, che parrebbe applicato agli argomenti, io potrei applicare i vari metodi a cosa?

cioè, io chiedevo solo una parametrizzazione che a seconda di casi mi permettesse di intervenire sul codice il meno possibile, indicando di volta in volta il nome della cartella che contiene i vari files che mi servono.

mi stai dicendo che avendo più cartelle diverse, mettiamo 4 casi diversi, potrei far girare il programma invece che una volta sola, 4 volte tutte insieme sui 4 casi diversi?

[ndakota]

Originariamente inviato da FrankieB76

ehmm... prima di tutto ti ringrazio della risposta.

però non è che abbia capito proprio tutto quello che mi hai scritto.

nel dettaglio, cosa fa esattamente quello che hai scritto tu? in particolare cosa fanno questo:

public class Main{
    public static void main(String[] args) {
        for (String e : args)
            System.out.println(e);
    }
}

e quest'altro?

public class Main{
    public static void main(String[] args) {
        for (String e : args) {
            metodo_a(e);
            metodo_b(e);
            metodo_c(e);
        }
    }
}

a vedere il for, che parrebbe applicato agli argomenti, io potrei applicare i vari metodi a cosa?

cioè, io chiedevo solo una parametrizzazione che a seconda di casi mi permettesse di intervenire sul codice il meno possibile, indicando di volta in volta il nome della cartella che contiene i vari files che mi servono.

mi stai dicendo che avendo più cartelle diverse, mettiamo 4 casi diversi, potrei far girare il programma invece che una volta sola, 4 volte tutte insieme sui 4 casi diversi?

Sì

public class Main{
    public static void main(String[] args) {
        for (String e : args)
            System.out.println(e);
    }
}

Questo codice itera sui parametri passati al main. Quelli che puoi specificare quando lanci il programma, come ti ha spiegato GByTe87. Cos'è che non ti è chiaro?

[FrankieB76]

allora, in verità mi pare di capire che quanto mi è stato suggerito non era esattamente quello che volevo chiedere io, anzi è DECISAMENTE MEGLIO!

io volevo solo esplicitare nel main (o dove sia possibile) la cartella o il folder dope pescare i dati da dare in pasto al programma per farlo eseguire. io poi a manina avrei cambiato la singola dicitura del main di volta in volta per i diversi casi.

avere la possibilità invece di far eseguire tutti i casi al programma in una volta sola invece è una idea ancora migliore. non ho però capito come dire al main "i dati sono qui, prendi questi e quelli", se posso dire in modo così barbaro.

la linea di comando:

java Main file1.txt dir/file2.txt dir2/file3.txt

cosa fa? in questo esempio file1 è senza cartella, mentre gli altri 2 sono nelle altre 2 cartelle? esattamente dove devo metterla questo tipo di linea?

poi:

public class Main{
    public static void main(String[] args) {
        for (String e : args)
            System.out.println(e);
    }
}

cosa fa questo? che significa che mi scrive e? cos'è e? o meglio, dove scrivo io cosa è e?

scusate, ma siccome ho un programma di 1200 righe di comando, di cui solo il main una 70ina, con 7 metodi che in parte utilizzano quei files, in parte ne utilizzano altri prodotti dai primi, e che tutti questi files usati, prodotti e riusati, stanno in una cartella diversa a seconda del caso (sto gestendo un grafo, ogni cartella fa riferimento ad un grafo diverso) potreste suggerirmi esplicitamente un template di quello che serve che io faccia, diversamente da come ho fatto io adesso?

public class Programma {

   public static void main(String[] args) {
   ...
   metodo_a ("data1/file_a.txt")
   metodo_b ("data1/file_b.txt")
   metodo_c ("data1/file_c.txt")
   ...
   } //fine main
} //fine classe

che poi a manina dovrei cambiare scrivendo "data2" ovunque compaia "data1" per prendere i risultati dei diversi casi.

invece cosa devo aggiungere per fare una semplice cosa del tipo

public class Programma {

   public static void main(String[] args) {
   ...
   metodo_a ("file_a.txt")
   metodo_b ("file_b.txt")
   metodo_c ("file_c.txt")
   ...
   } //fine main
} //fine classe

e farla ciclare, come suggeritomi da GByTe87, su tutti i casi di mio interesse?

grazie ancora

[FrankieB76]

up!

[ndakota]

Ti darei una mano volentieri ma non ho ben capito cosa devi fare. I metodi perchè sono differenziati? Perchè ne hai uno a, uno b e uno c? Anche i file sono in qualche modo da differenziare?

[FrankieB76]

Originariamente inviato da ndakota

Ti darei una mano volentieri ma non ho ben capito cosa devi fare. I metodi perchè sono differenziati? Perchè ne hai uno a, uno b e uno c? Anche i file sono in qualche modo da differenziare?

beh, ho un algoritmo da eseguire e devo applicare metodi diversi in sequenza; ho messo a, b, c, ma potrei anche mettere i nomi reali, se serve... anche i file sono 4 in tutto, perche devo acquisire dati diversi in input, e ogni volta che avvio il programma devo acquisire dati diversi da tutti questi file. ogni caso ha i suoi dati specifici, invece di cambiare i nomi dei file sul programma java volevo sapere se esisteva un comando singolo per ordinare al programma di prendere i dati da una specifica cartella piuttosto che da un'altra.

poi mi era stata prospettata la possibilità di far eseguire in sequenza tutti i casi, uno dopo l'altro, ma non ho capito come...

cioè, veramente pensavo fosse una questione davvero banale, e secondo me in effetti lo è veramente, ma non so come spiegarmi meglio....

[ndakota]

import java.io.File;

public class Prova {

	public static void main(String[] args) {
		
		for(String directory : args) {
			
			File[] files = new File(directory).listFiles();
			
			for(File f : files) {
				
				System.out.println(f.toString());
			}
		}
	}
}

Dunque, da quel che ho capito vuoi prendere in input un numero variabile di directory e applicare i metodi a, b, c a tutti i file in quelle cartelle. Con il codice qua sopra, se passi argomenti al main, cicla su queste directory, per ognuna tira fuori tutti i file di quella directory, cicla su questi file e per ognuno, in questo caso, stampa il nome con path del file. Nel tuo caso dovresti sostituire la stampa con le chiamate ai tuoi vari comandi, passandogli il nome del file.
Per passare le directory al tuo programma, dipende come lo esegui. Se lo lanci da terminale dovrai passarle tramite comando

java Prova directory1 directory2 directory3

Se lo vuoi lanciare da Eclipse, anzichè cliccare su Debug o Run, apri la rispettiva Debug Configurations o Run Configurations dal menù a tendina. Vai sul tab arguments e nello spazio Program arguments puoi specificare i tuoi argomenti(che se ho capito bene saranno directory). Occhio che se ci sono spazi devi mettere tra virgolette il nome, se hai più parametri separati da spazio, come segue per esempio

"C:\Documents and Settings\utente\workspace" "C:\Documents and Settings\utente"

Se c'è qualcosa che non torna dimmi cosa ho frainteso e cerchiamo di aggiustarlo.

[FrankieB76]

grazie Ndakota della risposta.

allora, vediamo se ho capito.
intanto devo impostare il programma in questo modo:

import java.io.File;

public class Prova {

	public static void main(String[] args) {
		
		for(String directory : args) {
			
			File[] files = new File(directory).listFiles();
			
			for(File f : files) {

                                              metodo_a ("file_1");
                                              metodo_b ("file_2");
                                              metodo_c ("file_3");

			}
		}
	}
}

esattamente cosa mi fa questa linea:

File[] files = new File(directory).listFiles();

???

e fatto ciò, usando io eclipse, dovrei andare a scrivere l'indirizzo nel mio pc di quelle cartelle, nello spazio Program arguments dove mi hai detto tu?

comunque queste cartelle, che compaiono nel mio workspace, nello spazio che si è creato quando ho iniziato un nuovo project, sono visibili anche nella colonnina del package explorer della pagina di eclipse, non c'è un comando più diretto da programma?

non c'è una cosa del tipo:

metodo_a ("data_h/file_1")

che mi permetta di specificare la cartella data_h invece che nella linea di comando come compare qui, più in alto da un'altra parte? io ipotizzavo nella dichiarazione del main inizialmente, ma non ne ho la più pallida idea se e come si possa fare una cosa simile.

questo sarebbe per il caso in cui io volessi far girare il programma una sola volta, con una serie di dati, mentre ovviamente volendo far girare il programma n volte, su n diverse serie di dati, ok il for che mi avete spiegato, ma non potrei sempre indicare questa serie di cartelle da qualche parte nel programma?

tornando all'esempio che mi hai dato tu, al posto della linea

System.out.println(f.toString());

devo inserire tutto il contenuto del mio main? comprese le dichiarazioni delle variabili, e di altre strutture dati più complesse? perche a seconda dei casi, molte di esse dovrebbero essere inizializzate da zero, come se non avessi mai cominciato, no?

[ndakota]

Originariamente inviato da FrankieB76

grazie Ndakota della risposta.

allora, vediamo se ho capito.
intanto devo impostare il programma in questo modo:

import java.io.File;

public class Prova {

	public static void main(String[] args) {
		
		for(String directory : args) {
			
			File[] files = new File(directory).listFiles();
			
			for(File f : files) {

                                              metodo_a (f);
                                              metodo_b (f);
                                              metodo_c (f);

			}
		}
	}
}

Nella mia visione delle cose era così. Stiamo ciclando sui file. Per ogni file, su quel file esegui tutti e tre i metodi. Ma potrei aver capito male io.

esattamente cosa mi fa questa linea:

File[] files = new File(directory).listFiles();

???

Questa istruzione inizializza un array di File, precisamente con i file della directory "directory".


e fatto ciò, usando io eclipse, dovrei andare a scrivere l'indirizzo nel mio pc di quelle cartelle, nello spazio Program arguments dove mi hai detto tu?

Che io sappia solo lì puoi passare argomenti ad un programma. Altrimenti puoi cablare delle stringhe dentro al codice, tranquillamente. E' meno bello ma puoi farlo. Però devi capire te cosa ti conviene cablare. Io sinceramente sono ancora un po' confuso

comunque queste cartelle, che compaiono nel mio workspace, nello spazio che si è creato quando ho iniziato un nuovo project, sono visibili anche nella colonnina del package explorer della pagina di eclipse, non c'è un comando più diretto da programma?

non c'è una cosa del tipo:

metodo_a ("data_h/file_1")

che mi permetta di specificare la cartella data_h invece che nella linea di comando come compare qui, più in alto da un'altra parte? io ipotizzavo nella dichiarazione del main inizialmente, ma non ne ho la più pallida idea se e come si possa fare una cosa simile.

questo sarebbe per il caso in cui io volessi far girare il programma una sola volta, con una serie di dati, mentre ovviamente volendo far girare il programma n volte, su n diverse serie di dati, ok il for che mi avete spiegato, ma non potrei sempre indicare questa serie di cartelle da qualche parte nel programma?

Sì, come detto potresti cablare nel codice delle stringhe che rappresentano delle directory. Però, potresti successivamente volerle modificare. Passandole al programma come parametri potresti potenzialmente non dover più modificare il codice invece.

tornando all'esempio che mi hai dato tu, al posto della linea

System.out.println(f.toString());

devo inserire tutto il contenuto del mio main? comprese le dichiarazioni delle variabili, e di altre strutture dati più complesse? perche a seconda dei casi, molte di esse dovrebbero essere inizializzate da zero, come se non avessi mai cominciato, no?

Non so. Dipende com'è il tuo main. Faccelo vedere

Risposte in grassetto.

[FrankieB76]

Originariamente inviato da ndakota

Sì, come detto potresti cablare nel codice delle stringhe che rappresentano delle directory. Però, potresti successivamente volerle modificare. Passandole al programma come parametri potresti potenzialmente non dover più modificare il codice invece.

ecco io mi concentrerei su questo punto, piuttosto che parlare del mio main, che è una serie di richiami a metodi su diversi file e inizializzazioni di strutture e dichiarazioni di variabili. dire che uso una linea del tipo

t.riempimatrice ("data1/nodi_matrice.txt");

non aggiunge niente alla chiacchiera.

se io passo, come mi dici tu, la cartella con i miei file, poi nel corpo del programma non devo scrivere più niente di "variabile"? posso lasciare semplicemente i nomi dei file?

come risolvo la questione dei diversi esempi a mia disposizione, ovvero i file nelle cartelle data1, data2, data3, ecc ecc?

ti ringrazio della pazienza...