Newsgroup: it.comp.java
Titolo: if con molteplici or

Dunque:
ho una classe java che ha un metodo che recupera un parametro String.
tale parametro puo' avere molteplici valori e all'interno del metodo c'č
un if cosě strutturato
if((param.equals("QA"))||(param.equals("aA"))||(param.equals
("zA"))||(param.equals("sdQA"))||(param.equals("QAw1"))||(param.equals("QAs"))||
(param.equals("QzA"))||(param.equals("QAaaq1"))||(param.equals("zzz"))||(param.e
quals("oo")))
{
....codice
}
insomma per intenderci ci sono vari OR(e potrebbero anche crescere)
dal punto di vista funzionale tutto ok ma da quello della sintassi mi
sembra stia diventando unpo' strano.
come posso modificare una simile sintassi per renderla leggibile???
ho visto che switch si usa solo per i char e per gli int; ho pensato
magari di mettere tutte le stringhe in un array(o un vettore) e poi usare
un if tipo:
if(param č nel vettore)
{
....codice
}
mi conviene fare qualcosa di simile o č meglio lasciare il codice come č???
suggerite qualche altra soluzione??
grazie
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 mi conviene fare qualcosa di simile o è meglio lasciare il codice come è???
Se è un problema di leggibilità, ti conviene semplicemente formattare il 
codice come si deve.
if( stringa.equals("Pippo") ||
     stringa.equals("Pluto") ||
     stringa.equals("Paperino") ) {
     System.out.println("Ora lo leggo bene");
}

 diana_est wrote:




con un vettore( o qualcosa di simile)non sarebbe più pulito(anche se forse
meno prestante)?


 }
Qualcosa tipo:
public boolean uguale(String s, String[]elenco)
 {
   boolean u=false;
   for (int i=0;i<elenco.length;i++)
    {
      if (s.equals(elenco[i])
       {u=true;}
    }
  return(u);
 }
da richiamare con
if(uguale(param,new 
String[]{"QA","aA","zA","sdQA","QAw1","QAs","QzA","QAaaq1","zzz","oo"}))
ecc... 

 suggerite qualche altra soluzione??
Bisognerebbe capire il contesto per vedere se magari sarebbe il caso di 
sfruttare il polimorfismo (p.e. se hai una serie di if/else)..
Ciao!
pole
-- 
ammentos - a lightweight persistence framework for JDK5
http://www.sourceforge.net/projects/ammentos
http://ammentos.biobytes.it

Se usi un'ArrayList, puoi usare contains(Object param)

 pole
grazie a tutti per i suggerimenti.
una cosa:come potrei sfruttare il polimorfismo in caso di una serie di
if/else?


 Se usi un'ArrayList, puoi usare contains(Object param)
grazie a tutti per i sufggerimenti


 if/else?
E' il caso tipico utilizzato per spiegare il polimorfismo. Invece di un 
codice simile (forzatamente sporco e non OOP)
if ( animal.getType() == DOG )
{
	System.out.println( "bau!" );
}
else if ( animal.getType() == CAT )
{
	System.out.println( "miao!" );
}
Si usa semplicemente qualcosa tipo:
animal.speak();
Ovviamente questo presuppone la creazione di una classe Dog e una classe 
Cat che implementano correttamente il verso del rispettivo animale :)
Penso di poter dire che nella programmazione OOP l'esistenza di if/else 
statement troppo complessi indica spesso (salvo alcuni casi) un cattivo 
design.


 pole
ah ok grazie.
ma non centra molto col mio problema
cmq grazie per il chiarimento


 --
 ...ma sicuramente è cattiva programmazione mettere tutti quei codici
nel programma invece che archiviarli da qualche parte (al limite anche
come parametri statici di una classe dedicata).

Ciao
un vecchio trucco di programmazione era quello di fare una ricerca per
sottostringhe .. nel seguente modo
if( "-QA-aA-za-sdQA-QAw1-QAs-QzA-QAaaq1-zzz-".indexOf( "-" +param +"-"
)!=-1 )
{
....codice
}
chiaramente dipende dal contesto, ma in questo caso potrebbe andare, e
ti evita un sacco di pippe mentali.

Molto piu' pulito cosi'. Il computer e' nato per essere programmabile!
Io pero' farei una modifichina:
/* Tante clausole OR significa che basta un true perche' la condizione
sia verificata. Quindi se il primo e' un true, anche gli altri sono
true.
Il contrario per gli and, basta un false perche' tutto sia false.
Implementi la lazy-evaluation che gia' esiste in java e avresti
pressoche' le stesse performance */
 public boolean uguale(String s, String[]elenco) {
   boolean u=false;
   for (int i=0;i<elenco.length;i++)    {
      if (s.equals(elenco[i]) {
        return true;  
      }
    }
  return false;
 } 
Saluti,
Davide

 Davide
scusa ma "Molto piu' pulito cosi'" come???
la tua soluzione la capisco ma che significa "implementi la
lazy-evaluation che gia' esiste in java..."?
grazie (appena ho tempo cerco qualcosa sulla lazy-evaluation )


 lazy-evaluation che gia' esiste in java..."?
In sostanza vuol dire che appena trovi un true (che essendo una 
espressione OR rende tutto true) ritorni il risultato ed eviti di 
valutare tutte le successive clausole.
Saluti
CarMas

 CarMas
grazie.
ok e appena trovi un false (nelle espressione AND) ritorna false ed evita
di valutare il resto, giusto??
sarò gnucco ma non capisco cosa centra con il resto del discorso, non
capisco come è collegato
cmq grazie



Ma gli esempi per spiegare come si usa il polimorfismo sono sempre (e solo!)
Animali/Strumenti musicali/Forme geometriche???
Oppure, più semplicemente, hai studiato dove ho studiato io???:-)
Ciao!
Kingofcastle

 Kingofcastle
anchio ;-)


 Oppure, più semplicemente, hai studiato dove ho studiato io???:-)
LOL :) A pensarci bene sono gli esempi per spiegare qualsiasi cosa, 
dall'aritmetica alle elementari, alla logica etc.
Sarà perché la natura è sempre la miglior programmatrice esistente :)


 cmq grazie
riletto e capito il collegamento, grazie


>>valutare tutte le successive clausole.
anche quando fai l'OR short-circuited (|| invece di |) valuti le 
condizioni fino a che trovi la prima vera.. e t eviti di valutare le 
altre...
-- 
             {2Nd+BESt}
-----------------------------------
never underestimate human stupidity