Utilizzo del tag option:collection STRUTS per ottenere una combo box.

Vediamo come si utilizza il tag STRUTS option:collection e la classe Java LabelValueBean per popolare,visualizzare e utilizzare una combo box.
Dentro il form creiamo una lista e un campo che ci serve per la voce selezionata:

List listaCampi; // contiene la nostra lista di scelte
String campoSelezionato =""; // contiene la scelta selezionata

e ovviamente i metodi get e set:

public List getListaCampi() {
return listaCampi;
}
public void setListaCampi(List listaCampi) {
this.listaCampi = listaCampi;
}
public String getCampoSelezionato () {
return campoSelezionato;
}
public void setCampoSelezionato(String campoSelezionato) {
this. campoSelezionato = campoSelezionato;
}


Dentro la nostra classe (la nostra action) importatiamo la classe LabelValueBean : import org.apache.struts.util.LabelValueBean;
Poi Creiamo un metodo per popolare una lista;il metodo si chiama con :

chiamata al metodo:
List pippo=creaCombo();
Impostiamola dentro il form:

frm = (FRM_MIOFORM) form;
frm.setListaCampi(pippo);

dichiarazione del metodo:
protected List creaCombo() throws Exception {
List elencoCampi = new ArrayList();
elencoCampi.add(new LabelValueBean("Etichetta 1", "01"));
elencoCampi.add(new LabelValueBean("Etichetta 2", "02"));
elencoCampi.add(new LabelValueBean("Etichetta 3", "03"));
return elencoCampi;
}
Questa classe contiene un’ etichetta (es. Etichetta 1 ) e un valore (es. 01 ) che verrà nascosto all’utente.
Poi andiamo nella JSP. Per visualizzare la combo box scriviamo:

<table> <tr> <td>
<html:select name="FRM_MIOFORM" property="CampoSelezionato" onchange="document.FRM_MIOFORM.submit()" size="1"> <html:optionsCollection name="FRM_MIOFORM " property="ListaCampi" /> </html:select>
</td> </tr></table>

In questo modo verrà visualizzata la combo box e il valore scelto verrà messo nel campo CampoSelezionato.

Conversione di tipo in java. Da stringa ai tipi primitivi.

Conversione di tipo in java: seconda parte.
Vediamo l'elenco completo per le conversioni dal tipo String ai tipi primitivi:

Da String a boolean:
String pippo="true";
Boolean c = Boolean.valueOf(pippo);
boolean b = c.booleanValue();

Da Stringa a char:
String pippo="c";
char c=pippo.charAt(0);

Da Stringa a byte:
String pippo="1";
byte b=Byte.parseByte(pippo);

Da Stringa a short:
String pippo="1";
short s=Short.parseShort(pippo);

Da String a int:
String pippo="1";
int i=Integer.parseInt(pippo);

Da String a long:
String pippo="1";
long l=Long.parseLong(pippo);

Da String a float:
String pippo="1";
long l=Long.parseLong(pippo);

Da String a double:
String pippo="1";
long l=Long.parseLong(pippo);

Naturalmente queste conversioni possono essere fatte in molti altri modi e utilizzando altri metodi.

Conversione di tipo in java. Da tipi primitivi a Stringa.

Conversione di tipo in java. Da stringa a tipi primitivi e viceversa.
Prima parte.

Ecco l’ elenco completo dei tipi primitivi in Java. I tipi primitivi sono quei tipi di dati predefiniti nel linguaggio da cui si può partire per costruire altri tipi di dati:

boolean
possono assumere i valori true e false

char
sono i caratteri e sono di 16 bit.

byte
interi di 8 bit con segno, cioè i numeri compresi tra -2 alla settima e 2 alla ottava.

short
interi di 16 bit con segno.

int
interi di 32 bit con segno.

long
interi di 64 bit con segno.

float
reali di 32 bit in virgola mobile.

double
reali di 32 bit in virgola mobile.

E consideriamo anche il tipo String che non è invece primitivo.

Con quali metodi possiamo passare da un tipo all’altro? Ecco qua la lista completa per passare dai tipi primitivi ai tipi Stringa:

Da tipi primitivi a Stringa:

Da boolean a String:
boolean b=true;
String pippo=Boolean.toString (b);

Da char a String:
char c='c';
String pippo=String.valueOf(c);

Da byte a String:
byte b=1;
String pippo=Byte.toString(b);

Da short a String:
short s=1;
String pippo=Short.toString(s);

Da int a String:
int i=1;
String pippo=Integer.toString(i);

Da long a String:
long l=1;
String pippo=Long.toString(l);

Da float a String:
float f=1;
String pippo=Float.toString(f);

Da double a String:
double d=1;
String pippo=Double.toString(d);

La prossima volta vedremo come fare il passaggio inverso.

Qualche pillola di Java

In questo blog voglio elencare tutti quei trucchi,accorgimenti e semplici annotazioni che uno sviluppatore Java deve utilizzare spesso. Il tutto non ha alcuna pretesa di rigore o esaustività e deve essere considerato alla stregua di un semplice quaderno di appunti.