Newsgroup: it.comp.java
Titolo: Efficienza nel confronto tra stringhe

Ciao,
ho visto usare una cosa del tipo:
if ("".equals(variabile)) ...
C'č un buon motivo per farlo? O in genere, se ho una stringa e all'interno
di un ciclo devo confrontarla con degli altri elementi, cambia qualcosa se
chiamo la equals della stringa o degli altri elementi? Ovvero
stringa.equals(vettore[i])
č meglio/peggio/uguale di
vettore[i].equals(stringa)
Grazie, stefano.

 ha scritto nel messaggio
news:as7s7e$h1b$1...@geronimo.keycomm.it...

stai chiamando lo stesso metodo sella classe String , č lo stesso.

 vettore[i].equals(stringa)
forse funziona meglio cosi:
stringa.equals(vettore[i].toString())
o vettore[i].toString().equals(stringa)
comnque è la stessa cosa.

> if ("".equals(variabile)) ...
In linea di massima č meglio scrivere:
if ("".equals(variabile)) ...
che :
if (variabile.equals("")) ...
questo perchč qualora "variabile" fosse uguale a null il primo "if" andrebbe
in eccezione il secondo no.
Ed č anche facile dimostrarlo:
null.equals(variabile)  ECCEZIONE
variabile.equals(null) CORRETTO
By Car

Errata corrige:
null.equals("")  ECCEZIONE
"".equals(null) CORRETTO

 "".equals(null) CORRETTO
Apparte che un controllo preventivo quando le stringhe a priori possono
essere o non essere nulle andrebbe fatto sempre.
Secondo la logica Java il confronto con "null" andrebbe fatto con
l'operatore == e non equals().

 ha scritto nel messaggio
news:as81fd$7gh$1...@newsreader.mailgate.org...

concordo anzi per me è preferibile:
null.equals("")
e mettere un try catch per gestire il caso.

 l'operatore == e non equals().
E' vero ma non posso fare
if (string==string)
con la speranza che uno dei due sia null.
La cosa piů sicura č usare equals, che comunque torna false qualora una
delle due stringhe fosse null.

 e mettere un try catch per gestire il caso.
I try cactch andrebbero utilizzati solo per accesso a: files, db e risorse
esterne.
Qualunque altro utilizzo e segno di codice scritto male.
Scusate la presunzione ma sono convinto che un codice ben proggettato riesca
a ridurre a solo questi casi l'uso della try.
By Car

 ha scritto nel messaggio
news:as823g$sit$1...@lacerta.tiscalinet.it...

e come fai a sapere se una stinga da dove proviene se è un campo di db?
non puoi dire che quello è il miglior modo di gestire una stringa.

 delle due stringhe fosse null.
Ottimizzi le cose paragonando un valore con == null.
string == string, anche se tutti e due non sono null non paragona
effettivamente le due stringhe ma l'oggetto.
Quindi, in taluni casi string == string non sempre da vero quando lo č.

 non puoi dire che quello è il miglior modo di gestire una stringa.
Pienamente ragione, i try catch aiutano se gestiti bene e fanno codice
pulito.

 non puoi dire che quello è il miglior modo di gestire una stringa.
L'information hiding prevede che chi utilizza una stringa ( o qualsiasi
altro oggetto)  non debba preoccuparsi se questa è stata impostata con dati
provenienti da un db, un file o altro.
L'unica cosa di cui dovrebbe preoccuparsi e verificare che al letterale
corrisponda effettivamente un oggetto e, chiaramente, verificarne il
contenuto.
By Car

> Quindi, in taluni casi string == string non sempre da vero quando lo è.
String a="Carlo"
String b="Carlo"
if (a==b)
è l'unico caso in cui la condizione torna vera
String a="Carlo"
String b=new String ("Carlo")
if (a==b)
in questo caso già torna folse.
Scrivere codice così mi sembra follia, fare debuging ancora peggio.
By, Car


l'information hiding è un principio della programmazione ad ogetti
che si basa sull'idea che al fine di utilizzare un oggetto, è sufficiente
conoscere la sua interfaccia verso l'esterno  fin qui OK, ma se io supero il
controllo di una stinga vuota questo mi causa
problemi es: se devo estrarre una sottostringa ?

 problemi es: se devo estrarre una sottostringa ?
Ed è per questo che la classe String offre tutti gli strumenti per la
gestione della stessa senza dove ricorrere al try.
Se usi un try per gestire una stringa è perchè non hai voluto utilizzare i
metodi che questa ti offre.
if (variabile!=null && variabile.equals("pippo")
la try con le stringhe è proprio una zozzeria :-)

un altro esempio:
if (variabile!=null && variabile.length()>20)
    stampa(variabile.substring(5,20);


ci sei arrivato
if (variabile!=null && variabile.equals("pippo")
e non
 if("".equals(variabile))
che č propriouna zozzeria

  if("".equals(variabile))
e perchč mai.
se ho una costante; e "" lo č.
E voglio verificare che una variabile sia uguale alla mia costante e meglio
scrivere
if("".equals(variabile)) che if(variabile.equals(""))
cosě facendo se la variabile fosse null non avrei eccezioni e eviterei un
controllo in piů.
Il fatto che a queste due soluzionisia preferibile
if (variabile!=null && variabile.equals("pippo")
č un altro discorso.
Non era questa la domanda di Stefano.
Ti ricordo che voi volevate addirittura usare una try.
Mi sembra un po esagerato.

 Ti ricordo che voi volevate addirittura usare una try.
io continuo a preferirlo

 vettore[i].equals(stringa)
La domanda e' mal posta perche' se vettore[i] non contiene
un oggetto String i due metodi equals(..) potrebbero lavorare
in maniera differente.

 io continuo a preferirlo
Il modo è bello perchè vario :-)
Ciao,
by Car


Comunque, nel caso in cui vettore[i] sia di tipo String, il confronto ha
complessita' nel caso pessimo O(n), dove n e' la lunghezza della stringa di
lunghezza massima.
E' questo e' vero sia nel caso si usi
stringa.equals(vettore[i])
che nel caso in cui si usi
vettore[i].equals(stringa)

 di lunghezza massima.
beh... allora "l'ingegnere" che ha progettato il metodo String.equals()
dev'essere stato molto furbo visto che se due strighe non hanno la stessa
lunghezza e' implicito che siano differenti, quindi O(n) non centra ^_^


mai risposta fu' piu' azzeccata ;-)))
Ciao

 ha scritto nel messaggio
news:3lRF9.39743$2B1.1...@twister2.libero.it...

Beccato!!!   ^_^
Correggo:
...nel caso in cui vettore[i] sia di tipo String, il confronto ha
complessita' O(n), dove n e' la lunghezza di 'entrambe' le stringhe.


Per i miei gusti questo thread sta andando avanti + del dovuto.
Se consulti qualsiasi manuale (anche per principianti) dice che la
comparazione tra oggetti va effettuata con il metodo equals() e i dati di
tipo semplice (tipo int, long,short, ecc...) con ==.
Detto questo concludo.

 tipo semplice (tipo int, long,short, ecc...) con ==.
Ma li hai letti i miei post?
Te lo chiedo perchè quello che dici è quello che sosteniamo tutti.
Nessuno ha affermato di voler confrontare due stringhe con ==
Ciao.


Copio e incollo il messaggio sopra il mio...


 in questo caso già torna folse.
Mi sa che Java non lo conosci molto bene :-)
Quello che faccio nel mio esempio non è verificare se la stringa Carlo è
uguale alla stringa Carlo (come sostieni tu) ma verificare se i letterali
"a" e "b" fanno riferimento alla stessa istanza.
Non è difficile, se vuoi approfondire l'argomento dovresti andare a leggere
la pagina 4 o 5 di ogni buon libro su Java :-)
By Carlo


Vabbè dai, sei uno che non demorde...
Se pensi tu di conoscere Java non avresti continuato o per lo meno risposto
a questo thread come hai puntulamente fatto proponendo di comparare costanti
a variabili, cosa per altro inopinabile e brutta, e non viceversa.
Vabbè, ora basta perchè mi sa che tu ti sei fermato alla pagina 4 o 5 di
ogni buon libro su Java ;) proponendo "".equals(variabile).
In effetti poi, 3 anni e mezzo di sviluppo lavorativo con Java per alcuni è
poco per altri è un tempo sufficiente per imparare il linguaggio.
Continua cosi...
Daniele.

 poco per altri è un tempo sufficiente per imparare il linguaggio.
Lasciamo stare, i numeri perchè non dimostrano assolutamente nulla.
L'importante è essersi confrontati su un problema che per quanto semplice ci
ha visto su fronti distinti.
Rimango della mia opinione. E sopratutto rimango dell'idea che l'esempio
if( x == y) probabilmente l'avevi intepretato male, dando così inizio ad una
polemica sterile e inutile.
Chiudo qui i miei interventi.
Peace,
by Car