Test sulle stringhe: substring

Analizzando il codice di convertStatement si nota come uno dei metodi più utilizzati sulle stringhe sia substring. Si è pensato quindi a qualche alternativa per implementare la stessa funzione, ma utilizzando altri metodi. Sono state create quindi altre 5 alternative al classico metodo substring.

1. Sub1: metodo substring classico, che per poterlo comparare con gli altri è stato incapsulato in una funzione.

static String sub1(String str, int begin, int end) {

return str.substring(begin, end); } sqlStatement function_before function_start function_after next system sequence

58

2. Sub2: utilizza il metodo getChars(int begin, int end, char[] dest, int

index). Questo metodo preleva dalla stringa su cui è chiamato i caratteri

compresi tra gli indici begin ed end, inserendoli nell’array di caratteri dest dalla posizione indicata da index. Tutte e quattro le variabili necessarie vengono passate come parametro. Si è pensato quindi di ottenere i caratteri della sottostringa grazie a getChars per poi creare una stringa con questi caratteri.

static String sub2(String str, int begin, int end) {

char[] dest = new char[end - begin];

str.getChars(begin, end, dest, 0);

return String.copyValueOf(dest); }

3. Sub3: utilizza il metodo subSequence(int begin, int end), che restituisce un oggetto di tipo CharSequence con i caratteri compresi tra i due indici passati per parametro. Dato che il metodo dovrebbe ritornare una stringa è sufficiente generarla con il metodo toString() applicato all’oggetto CharSequence appena ottenuto.

static String sub3(String str, int begin, int end) {

return str.subSequence(begin, end).toString(); }

4. Sub4: utilizza il metodo charAt(int index), che restituisce il carattere nella posizione indicata dall’indice passato come parametro. Il metodo viene inserito un ciclo for per ottenere tutti i caratteri necessari alla composizione della sottostringa, che vengono man mano copiati in un array di char. Da questo array verrà poi creata la stringa finale da ritornare. Sono stati inseriti inoltre dei controlli per valutare la correttezza

59

degli indici passati come parametro. Infatti è necessario controllare che gli indici non siano negativi, che l’indice di fine sottostringa sia maggiore di quello di inizio stringa ma non superiore alla lunghezza della stringa. Nei precedenti metodi non era necessario in quanto getChars e subSequence eseguono gli stessi controlli.

static String sub4(String str, int begin, int end)

throws IndexOutOfBoundsException {

if ((begin < 0) | (begin >= end) | (end >

str.length()))

throw new IndexOutOfBoundsException();

char[] dest = new char[end - begin];

for (int index = begin; index < end; index++) {

dest[index] = str.charAt(index); }

return String.copyValueOf(dest); }

5. Sub5: utilizza charAt(int index) come il precedente Sub4, ma i caratteri vengono aggiunti ad un oggetto di tipo StringBuilder mediante il metodo

append. Viene infine ottenuta la stringa grazie al metodo toString()

applicato all’oggetto StringBuilder.

static String sub5(String str, int begin, int end)

throws IndexOutOfBoundsException {

if ((begin < 0) | (begin >= end) | (end >

str.length()))

throw new IndexOutOfBoundsException();

StringBuilder dest = new StringBuilder(end-

begin);

for (int index = begin; index < end; index++) {

60 }

return dest.toString(); }

6. Sub6: utilizza uno dei costruttori dell’oggetto String, ovvero String(char[]

value, int begin, int end-begin). Questo costruttore crea una nuova stringa

copiando i caratteri presenti nell’array passato per parametro, iniziando dal carattere presente nella posizione indicata dal parametro begin. Il numero di caratteri copiati viene definito dall’altro parametro passato. L’array passato per parametro viene riempito di tutti i caratteri contenuti nella stringa di partenza mediante il metodo toCharArray().

static String sub6(String str, int begin, int end)

throws IndexOutOfBoundsException {

if ((begin < 0) | (begin >= end) | (end >

str.length()))

throw new IndexOutOfBoundsException();

char[] value = str.toCharArray();

return ((begin == 0) && (end == str.length())) ?

str : new String(value, begin, end - begin);

}

Sono state seguite le solite procedure descritte in precedenza in modo da ottenere valori medi significativi.

Si è pensato inoltre se i tempi di esecuzione potessero essere influenzati dalla lunghezza della sottostringa da ottenere. Per questo motivo sono stati ripetuti tutti i test con diverse lunghezze della sottostringa, ovvero 1, 100, 1.000 e 5.000 caratteri.

61

3.4.5 Test sulle stringhe: concatenamento

Un’operazione molto comune che può essere effettuata con le stringhe è il loro concatenamento. Un metodo tipico è quello di utilizzare il simbolo “+” tra le stringhe. Verrà creata una nuova stringa contenente il concatenamento tra le due. Naturalmente il concatenamento può essere ripetuto più volte consecutivamente. Il prezzo da pagare per questa comoda operazione è però il costo della creazione di una nuova stringa. Si è pensato quindi che se si utilizzasse un oggetto di tipo StringBuilder o StringBuffer non si avrebbe più questo costo, ma si andrebbe a modificare l’oggetto stesso.

Sono perciò state create 3 varianti del concatenamento.

1. Metodo1: concatenamento classico mediante il simbolo “+”.

All’interno del metodo sono state create delle stringhe e poi concatenate.

static String metodo1() {

String prova1 = "prova1"; String prova2 = "prova2"; String prova3 = "prova3"; String prova4 = "prova4"; String prova5 = "prova5"; String prova6 = "prova6"; String prova7 = "prova7"; String prova8 = "prova8"; String prova9 = "prova9"; String prova10 = "prova0";

return prova1 + prova2 + prova3 + prova4 + prova5 + prova6 + prova7 + prova8 + prova9 + prova10;

62

2. Metodo2: concatenamento con oggetto di tipo StringBuffer.

All’interno del metodo sono state create delle stringhe e un oggetto di tipo StringBuffer con la preallocazione della memoria necessaria. Sono state poi aggiunte all’oggetto StringBuffer tutte le altre stringhe mediante il metodo append.

static String metodo2() {

String prova1 = "prova1"; String prova2 = "prova2"; String prova3 = "prova3"; String prova4 = "prova4"; String prova5 = "prova5"; String prova6 = "prova6"; String prova7 = "prova7"; String prova8 = "prova8"; String prova9 = "prova9"; String prova10 = "prova0";

StringBuffer prova = new StringBuffer(60);

return(prova.append(prova1).append(prova2). append(prova3).append(prova4).append(prova5). append(prova6).append(prova7).append(prova8). append(prova9).append(prova10).toString()); }

3. Metodo3: concatenamento con oggetto di tipo StringBuilder.

Sostanzialmente identico al precedente, ma con l’utilizzo di un oggetto di tipo StringBuilder al posto di un oggetto di tipo StringBuffer.

static String metodo3() {

String prova1 = "prova1"; String prova2 = "prova2"; String prova3 = "prova3";

63

String prova4 = "prova4"; String prova5 = "prova5"; String prova6 = "prova6"; String prova7 = "prova7"; String prova8 = "prova8"; String prova9 = "prova9"; String prova10 = "prova0";

StringBuilder prova = new StringBuilder(60);

return(prova.append(prova1).append(prova2). append(prova3).append(prova4).append(prova5). append(prova6).append(prova7).append(prova8). append(prova9).append(prova10).toString()); }

Si è pensato però anche un altro test per fare in modo che il tempo impiegato per la generazione delle stringhe da concatenare non influenzasse il vero obiettivo, ovvero il tempo di esecuzione del concatenamento. La dichiarazione delle stringhe è stata quindi spostata all’esterno, creando degli attributi statici modificabili da tutti metodi. Il tempo di esecuzione del metodo si rivela quindi più aderente al tempo di esecuzione del concatenamento al suo interno.