Newsgroup: it.comp.java
Titolo: scelta tra 2 casi metodo main

Devo creare una classetta java che lanciata da console faccia 2 cose
(semplifico il tutto o almeno provo):
 1) esplorare in maniera ricorsiva una directory per cercare dei file
 2) esaminare la tabella Controlli con una select e poi (in base ai
controlli effettuati) scrivere nella tabella DatiTrovati i dati relativi
ai file trovati (nella directory) che soddisfano i controlli
 
 
ecco ho pensato a 2 modi
modo 1:
1)viene lanciato un primo metodo che esplora in maniera ricorsiva la 
directory  e scrive nella lista ListaFile tutti i file trovati nella
directory 
2) viene fatta un'unica select su Controlli e poi viene fatto ciclare il
ResultSet: per ogni riga del ResultSet viene poi iterata tutta ListaFile e
quando (e se) si trovano i file che soddifano i controlli derivanti da
quella riga del DB si fa la insert
modo 2: 
viene lanciato un metodo che esplora in maniera ricorsiva la directory  e
per ogni file trovato si esegue una select su Controlli (tirando fuori 1
solo record) e quando (e se)  quel record, confrontato con il file,
soddisfa il controllo si fa la insert
nel primo caso si farebbe un'unica select ma per ogni riga del ResultSet
si itererebbe su tutta la lista mentre nel secondo caos si itererebbe una
sola volta ma si farebbero tante select quanti sono gli elementi della
lista
quale vi pare il metodo migliore?
un'altra cosa: dal mio main posso chiamare solo metodi statici della mia
classe a meno che non istanzio un oggetto della mia classe (o magari di
un'altra); ecco, come si usa fare di solito? si istanzia un oggetto nel
main e si chiamano metodi non statici di quell'oggetto o si chiamano
direttamente i metodi statici senza quindi istanziare nulla?
grazie
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

diana_est ha scritto:

Non so quali siano i tuoi "controlli" ma immagino che siano dei criteri 
da applicare al nome del file se e' cosi':
1) leggo i "controlli" (resultset) e formo una RegEx.
2) Passo la regex al metodo che legge il FileSystem
3) Il metodo precedente mette *subito* a confronto il path+name letto e 
se fa "scopa" con la regex lo mette in listaFile (o addirittura lo 
scrive subito)
4) Se  non lo ho scritto subito scorro la lista risultato e faccio le 
insert (magari transazionalizzate se serve)
Statico non statico, il pallido principe di Danimarca gia' ha i suoi 
problemi! ;-{)
Se non hai bisogno di *istanziare* puoi andare statica senno' ti tocca 
andare dinamica, sempre che non vi siano vincoli in un senso o nell'altro.
Pensierino della sera: Una regex al giorno leva il medico di torno.
--
ac
ac

Alessandro Cara ha scritto:




azz forse avrei dovuto spiegare nel dettaglio
grazie per la soluzione che ora cercherò di adeguare al mio caso ma se tu
avessi dovuto scegliere tra i modi da me postati prima cosa avresti scelto?
garzie anche per la risposta nell'altro topic


> direttamente i metodi statici senza quindi istanziare nulla?
Volendo si puň fare cosě:
class Prova
  {
   public static void main(String[]args)
    {
     Prova prova=new Prova();//istanzia la classe dove si trova il main
     prova.mioMetodo();//applica metodo non statico della stessa classe
    }
   private void mioMetodo()
    {
     System.out.println("Bla bla bla...");
    }
   public Prova()
    {
     System.out.println("classe Prova");
    }
  }

 avessi dovuto scegliere tra i modi da me postati prima cosa avresti scelto?
Non lo so perche' il problema non e' chiaro, forse nessuno dei due.
Aborro cicli, if, e select ripetute.
Di tre cose (2 input ed un output) sono chiari, forse, solo i dati di 
FileSystem. Non sapendo come sono e come si presentano gli altri due e' 
pressoche' impossibile dare una risposta certa.
Comuque mediamente fra una operazione di IO ed una operazione in memoria 
e' da prediligere la seconda. Ho fustigato (non metaforicamente), a suo 
tempo, un giovane virgulto che faceva diecimila select invece di 
organizzarsi e farne una sola.
In questo mestiere l'assoluto non esiste. Rispetto ad una soluzione ci 
sono sempre pro e contro e non e' detto che una soluzione migliore in un 
certo contesto sia comunque "la migliore". Fermo restando che il rasoio 
di Occam deve essere lo strumento principe, ecco che rispunta il 
principe ;-{).
--
ac

   }
grazie a tutti


 quale vi pare il metodo migliore?
il modo 2 è tendenzialmente migliore. considera che se accedi ai singoli 
record della tabella per indice univoco i tempi di risposta sono i 
migliori che il db ti possa dare.

rootkit ha scritto:



eh ma ci accedo tante volte


rootkit ha scritto:

Tenuto presente il tuo "tendenzialmente", per capire. n casi per le due 
situazioni in cui "S" iterazioni di select e  "A" iterazioni di array 
"S" e "A" all'inizio valgono 10 e poi sono applicati con fattore 
moltiplicativo 10 (varie combinazioni)
1)
select bla....bla   "S"
while.next()
    for (i=0; i<array.length;i++)   "A"
        if(crit1==crit2)
              fai qualcosa e/o break;
2)
    for (i=0; i<array.length;i++)   "A"
        select bla....bla       "S" == 1 (puo' ritornare null)
I due metodi hanno ovviamente anche due logiche e tempi diversi se non 
si applica il break.
Nel primo caso 1 riga di select puo soddisfare piu elementi di array
Nel secondo caso posso dover fare la stessa select a fronte di n 
elementi di array
Se si applica il break non si cicla in modo completo
Il punto di equilibrio credo sia dato dal rapporto 
temposcorrimento1elemento/tempoesecuzionequery in cui il 
tempoesecuzionequery, da quello che e' la mia esperienza, e' abbastanza 
piu'  lungo  dell'altro  ("prepared" o non "prepared",  "indice" o non 
"indice", parte interessata)
Secondo me la situazione non e' cosi' lineare.
Ovviamente il codice e' "maccheronico" non sono stato a guardare la 
sintassi.
--
ac

 moltiplicativo 10 (varie combinazioni)
il mio "tendezialmente" è dovuto al fatto che non conosco le dimensioni 
di questi dati.
in ogni caso per tornare ai tuoi esempi mi permetto di suggerire  di 
mettere almeno i dati in una collection ordinata e su quella fare una 
Collections.binarySearch(). giusto per precisare... :P

 
Io facevo gli esempi, credo, dettati da diana_est. In un mio post avevo 
gia' scritto che, forse, non avrei fatto nessuna delle due cose da lei 
(lui?) prefigurate.
La ricerca dicotomica e' uno dei miei "amori", insieme alle regex,  al 
contenimento delle select ed agli array associativi (hashmap). Ce ne 
sono anche altri, "tendenzialmente" sono un fedifrago.
--
ac

 eh ma ci accedo tante volte
se sono tanti gli accessi vuol dire che sono tanti anche i dati che, 
nell'altra soluzione, ti carichi in memoria. va valutato. in ogni caso 
anche nell'altra soluzione dovrai ricorrere ad una binary search
http://tinyurl.com/57fey9
se non vuoi avere performance peggiori.
-- 
++ questo messaggio è scritto in forma ridotta per venire incontro alle 
vostre capacità mentali
http://unopuntozero.wordpress.com/
http://www.flickr.com/photos/marko_po/