Ciao.
Stai facendo un po' di cose inutili e altre concettualmente sbagliate.
1) Non ha senso passare per i formattatori (SimpleDateFormat e compagnia bella) per fare ciò che serve a te.
2) Se il test con instanceof ha dato esito positivo, allora l'oggetto è per forza di cose diverso da null, quindi l'if successivo che ne controlla la nullità non serve ed è concettualmente sbagliato.
3) Ti consiglio di usare sempre il printStackTrace() dell'eccezione quando ne viene sollevata una: la stampa del solo messaggio spessissimo è troppo poco per capire dove stia veramente il problema.
Andiamo con ordine: prima vediamo cosa puoi fare con ciò che hai predisposto, poi ti fornisco una soluzione per il problema dei NULL (ci sono già passato).
Se valori[jj] è di tipo java.util.Date, va semplicemente creato un oggetto java.sql.Date corrispondente e usato nella PreparedStatement:
if (valori[jj] instanceof java.util.Date) {
try {
java.util.Date myDate = (java.util.Date) valori[jj];
java.sql.Date d = new java.sql.Date( myDate.getTime() );
ps.setDate(jj+1, d);
} catch (Exception e) {
e.printStackTrace(); // Stampo lo stackTrace!
}
}
Questo è tutto ciò che puoi fare con la struttura che hai predisposto (ovvero un array di Object). In pratica, non puoi avere dei NULL perchè non potresti assegnarli alla PreparedStatement (di più, se tu avessi un valore null nell'array di Object, nessun test con instanceof sarebbe mai verificato).
Quindi, se tu volessi (e mi pare tu debba) trattare anche il caso di inserimento di un NULL per un campo di una tabella, devi fare uno step in più: ovvero, capire quale tipo di dato va inserito in quel determinato campo.
Per fare questo hai sostanzialmente 2 strade:
1) Effettuare una query di selezione sul DB, ottenere quindi un ResultSet, da questo ottenere il ResultSetMetaData e, con questo, indagare il tipo di dato di ciascun campo (molto laborioso)
2) Utilizzare una struttura dati diversa dall'array di Object, che ti dia anche l'informazione sul tipo di dato (soluzione preferenziale che ho adottato anch'io molte volte)
Un esempio. Costruisci una semplice classe bean che contenga due informazioni: il tipo di dato e il valore del dato.
public class Campo {
private int tipo;
private Object valore;
public Campo(int tipo, Object valore) {
this.tipo = tipo;
this.valore = valore;
}
... // getter e setter
}
A questo punto, invece di usare un array di Object, utilizzerai un array di oggetti Campo:
Campo[] valori = new Campo[2];
valori[0] = new Campo(java.sql.Types.VARCHAR, nome);
valori[1] = new Campo(java.sql.Types.DATE, data);
Così facendo hai l'informazione per trattare l'eventuale null:
switch( valori[jj].getTipo() ) {
case java.sql.Types.DATE:
if (valori[jj].getValore() != null) {
... // Costruisci il java.sql.Date d
ps.setDate(jj+1, d);
} else {
ps.setNull(jj+1, java.sql.Types.Date);
}
break;
case java.sql.Types.VARCHAR:
if (valori[jj].getValore() != null) {
ps.setString(jj+1, (String) valori[jj].getValore());
} else {
ps.setNull(jj+1, java.sql.Types.VARCHAR);
}
break;
...
}
Vedi tu se la cosa ti può andare bene.
Ciao.