Zoom Icon

Java Lezione 3

From UIC Archive

Java Lezione 3

Contents


Java Lezione 3
Author: Ken1986
Email:
Website:
Date: 06/10/2008 (dd/mm/yyyy)
Level: Working brain required
Language: Italian Flag Italian.gif
Comments:



Array

Supponiamo ad esempio di dover scrivere un programma che legga un certo numero di interi, di stamparli e d'indicare qual'è il minore. E' ovvio che prima dobbiamo leggere dobbiamo leggere tutti i numeri (o in generale tutti i dati) prima di poter dire qual'è il più piccolo. I metodi che possiamo usare sono due, il primo è di inserire n variabili per quanto sono gli interi (Ad es. numero1, numero2, numero3,...,numeron) oppure utilizzare l'array.
L'array in JAVA è un oggetto che realizza una raccolta di elementi di dati dello stesso tipo. Quindi possiamo avere array di interi, caratteri, double, float,..Come prima operazione dobbiamo dichiarare l'array utilizzando il seguente codice: int x[]; //oppure int []x; In questo caso verrà dichiarato un array d'interi. La seconda fase è quella di costruirlo tramite l'operatore new.
x = new int [10]; All'interno delle parentesi quadre "[..]" deve essere inserita la dimensione dell'array (nel nostro caso 10), cioè il numero degli elementi che esso potrà contenere. Prima e seconda fase possono avvenire nella stessa istruzione: int [] x = new int [10]; Nel momento in cui viene creato l'array, tutti i valori sono inizializzati a 0 per un array di tipo int o double, false per un array di tipo boolean e null per un array di oggetti (Argomento trattato successivamente. Vero Altered???? ehehe).Il numero utilizzato per accedere ad un particolare elemento di dell'array si chiama indice. Può assumere valore compreso tra 0 (incluso) e la dimensione dell'array (esclusa). Chi ha studiato un pò di analisi matematica capirà ancora di più: [0,dimensione).
Ad es. se voglio stampare il primo elemento dell'array dovrò scrivere: System.out.println(x[0]); //Invece se voglio stampare l'ultimo: System.out.println(x[9]); //Per modificare un elemento dell'array faremo così: int [] x = new int [10]; x[0] = 10; x[1] = 20; Se inseriamo un valore di indice errato, il nostro compilatore ci darà un errore di tipo ArrayIndexOutOfBoudsException. Ad es: int []x = new int [10]; x[10] = 100; Una volta che viene creato l'array, non sarà più possibile cambiare la sua dimensione. Quindi la dimensione dell'array è immutabile. E' possibile accedere alla lunghezza (o dimensione) dell'array tramite la variabile length. int []x = new int [10]; System.out.println(x.length);

OPERAZIONI CON GLI ARRAY

1) Scansione int [] sequenza = new int [10]; int x = 4;

for (int i = sequenza.length/2; i < sequenza.length; i++)
        sequenza[i] = x * (i+5);



2) Lettura int [] x = new int [10];

for (int i = 0; i < x.length; i++)
        x[i] = Console.readInt("Inserisci un intero: ");



3) Stampa int [] x = new int [10];

for (int i = 0; i < x.length; i++)
        System.out.println(x[i]);

RICERCA DI UN ELEMENTO

Esempio di algoritmo di ricerca di un determinato elemento in un array. double [] vettore = new double [20]; double elemento = 3; //Questo è l'elemento da cercare boolean trovato = false; //Riempire l'array come meglio si crede

for (int i = 0; i < vettore.length; i++)
        if (vettore[i] == elemento)
                trovato = true;
if (trovato = true)
        System.out.println("L'elemento è stato trovato");
else
        System.out.println("L'elemento non è stato trovato");

TROVARE IL VALORE MINIMO DI UN ARRAY

Esempio di un algoritmo tipo utile per trovare il valore minimo di un array. double [] vettore = new double [20]; //Riempire l'array come meglio si crede double minimo = vettore[0];

for (int i = 0; i < vettore.length; i++)
        if (vettore[i] < minimo)
                minimo = vettore[i];

System.out.println(minimo);


Stringhe

In Java non esiste un tipo primitivo strina, ma esiste una classe predefinita: String (quindi le stringhe in Java sono oggetti.
Il significato di oggetto verrà appreso nelle lezioni successive, quando si inizierà a parlare di programmazione orientata a oggetti OOP).Quindi possiamo definire che una Stringa è una sequenza di caratteri, che in Java sono racchiuse fra virgolette, però non fanno parte della stringa...Le operazioni sulle stringhe vengono effettuate mediate i metodi della classe String.
Es. dichiarazione di tipo string String NomeSito = "www.ogmdevelopment.com"; //Per inizializzare una stringa vuota faremo nel seguente modo:

String Nome = "" ;

//Invece per leggere una stringa da Input tramite la classe Console, faremo così: String Nome = Console.readString("Inserisci il tuo nome: ");

METODO length()

Il metodo length() della classe String calcola la lunghezza della stringa, cioè il numero di caratteri che compongono la stringa. Es. String s = "Hello"; int n = s.length(); //Calcola il numero di caratteri in questo caso 5 Se si ha una stringa vuota il valore sarà ovviamente 0...

METODO charAt()

Questo metodo permette di estrarre da una stringa, il carattere occupato alla posizione n. String s = "Hello";

System.out.println(s.charAt(0));    //Varrà H

Questo metodo restituisce un carattere, no una stringa

CONCATENAZIONE DI PIU' STRINGHE

La concatenazione di più stringhe avviene tramite l'operatore + String s1 = "OGM";

String s2 = "development";
String s3 = s1 + s2;
System.out.println(s3);  // Cosa stamperà secondo voi???

L'operatore di concatenazione è molto potente, infatti se è una delle due o più espressioni, poste a destra o a sinistra dell'operatore +, è una stringa, anche l'altra espressione verrà automaticamente "convertita" in una stringa.

String s1 = "OGM Team" ;
String s2 = "Numero ";
int n = 1;
String s3 = " al mondo";
System.out.println(s1 + s2 + n + s3);

METODO substring(int start, int end)

Questo metodo estrae una sottostringa. Questo metodo crea un altro oggetto di tipo String. String s1 = "Hello, World"; String sub = s1.substring(0, 5); //sub conterrà Hello Se non viene inserito il secondo parametro, verrà preso in considerazione tutto quello che c'è dopo l'ennesimo carattere...METODO indexOf()Questo metodo verifica se la stringa su cui viene invocato il metodo contiene un determinato carattere oppure una determinata stringa. Se il carattere/stringa viene trovato, viene restituita la posizione di esso, altrimenti verrà restituito -1. String s = "OGM";

System.out.println(s.indexOf(M));  //Verrà stampato 2

//oppure String s = "OGMdevelopment";

System.out.println(s.indexOf(OGM));  //Verrà stampato 0

METODO lastIndexOf()

Verifica se la stringa su cui viene invocato il metodo, contiene una determinata stringa. Se la stringa c'è, restituisce l'ultima posizione, altrimenti -1.

String s = "mamma";
System.out.println(s.lastIndexOf(ma));  //Stamperà 4

METODO equals()

Serve a confrontare due stringhe. E' un errore utilizzare l'operatore =

String s1 = "ciao";
String s2 ="ci" + "ao";
if (s1.equals(s2)
    System.out.pritnln("Le due stringhe sono uguali");
else
    System.out.pritnln("Le due stringhe non sono uguali");


Algoritmi di ricerca

Se abbiamo una sequenza di elementi (array) e occorre verificare se un elemento fa parte della sequenza, dobbiamo affidarci agli algoritmi di ricerca. Possiamo trovarci in due casi:

  1. La sequenza non è ordinata a priori, quindi occorre eseguire una ricerca lineare o sequenziale;
  2. La sequenza è già ordinata, quindi è sufficiente eseguire una ricerca binaria.

RICERCA LINEARE

La ricerca lineare (o sequenziale) in una sequenza (array) è strutturata nel seguente modo:

  • Vengono confrontati tutti gli elementi della sequenza con l'elemento da ricercare (detta chiave);
  • Quando si trova un elemento uguale alla chiave la ricerca è terminata.

Viene detta sequenziale perchè gli elementi della sequenza vengono scanditi uno dopo l'altro.(Se l'elemento viene trovato prima di raggiungere la fine della sequenza, non è più necessario eseguire).L'implementazione di questo algoritmo in java è dato dal seguente metodo:

public static int ricLineare(int[] seq, int chiave){

    int ind_elem = -1;
    for (int i = 0; ind_elem == -1 && i < seq.length; i++){
        if(seq[i] == chiave)
            ind_elem = i;
    }
    return ind_elem;
}

Se la ricerca ha avuto esito positivo, il metodo restituirà l'indice dell'elemento, altrimenti -1.

RICERCA BINARIA

Questo algoritmo come detto prima, cerca l'elemento nella sequenza che è già ordinata a priori. Cerca l'elemento in maniera crescente, eseguendo i seguenti passi finchè l'elemento viene trovato o si è conclusa la ricerca senza aver fornito alcun risultato:

  1. Confronta la chiave con l'elemento centrale della sequenza;
  2. Se la chiave è uguale all' elemento centrale, la ricerca si conclude positivamente;
  3. Se la chiave è maggiore dell'elemento centrale, si esegue la ricerca nella sotto sequenza a destra;
  4. Se invece la chiave è minore dell'elemento centrale dello spazio di ricerca, si esegue la ricerca nella sotto sequenza a sinistra.

L'implementazione di questo algoritmo in java è dato dal seguente metodo: public static int ricBinaria(int[] seq, int chiave){</nowiki>

    int indice = -1;
    int inizio = 0;
    int centro;
    int fine = seq.length -1;
    while(indice == -1 && inizio <=fine){
        centro = (inizio + fine) / 2;
        if (seq[centro] == chiave)
            indice = centro;
        else
            if (chiave > seq[centro])
                inizio = centro + 1;
            else
                fine = centro - 1;
    }
     return indice;
}

Come per il metodo precedente: se la ricerca ha avuto esito positivo, il metodo restituirà l'indice dell'elemento, altrimenti -1.


Note Finali

Ken1986


Disclaimer

I documenti qui pubblicati sono da considerarsi pubblici e liberamente distribuibili, a patto che se ne citi la fonte di provenienza. Tutti i documenti presenti su queste pagine sono stati scritti esclusivamente a scopo di ricerca, nessuna di queste analisi è stata fatta per fini commerciali, o dietro alcun tipo di compenso. I documenti pubblicati presentano delle analisi puramente teoriche della struttura di un programma, in nessun caso il software è stato realmente disassemblato o modificato; ogni corrispondenza presente tra i documenti pubblicati e le istruzioni del software oggetto dell'analisi, è da ritenersi puramente casuale. Tutti i documenti vengono inviati in forma anonima ed automaticamente pubblicati, i diritti di tali opere appartengono esclusivamente al firmatario del documento (se presente), in nessun caso il gestore di questo sito, o del server su cui risiede, può essere ritenuto responsabile dei contenuti qui presenti, oltretutto il gestore del sito non è in grado di risalire all'identità del mittente dei documenti. Tutti i documenti ed i file di questo sito non presentano alcun tipo di garanzia, pertanto ne è sconsigliata a tutti la lettura o l'esecuzione, lo staff non si assume alcuna responsabilità per quanto riguarda l'uso improprio di tali documenti e/o file, è doveroso aggiungere che ogni riferimento a fatti cose o persone è da considerarsi PURAMENTE casuale. Tutti coloro che potrebbero ritenersi moralmente offesi dai contenuti di queste pagine, sono tenuti ad uscire immediatamente da questo sito.

Vogliamo inoltre ricordare che il Reverse Engineering è uno strumento tecnologico di grande potenza ed importanza, senza di esso non sarebbe possibile creare antivirus, scoprire funzioni malevole e non dichiarate all'interno di un programma di pubblico utilizzo. Non sarebbe possibile scoprire, in assenza di un sistema sicuro per il controllo dell'integrità, se il "tal" programma è realmente quello che l'utente ha scelto di installare ed eseguire, né sarebbe possibile continuare lo sviluppo di quei programmi (o l'utilizzo di quelle periferiche) ritenuti obsoleti e non più supportati dalle fonti ufficiali.