I linguaggio Java di meatim
Si può studiare un linguaggio di programmazione attraverso un blog? Perchè no? L'enorme visibilità e la facilità di consultazione del blog, secondo me, lo consentono. Comunque vale la pena di provarci, con l'aiuto del mio studente Alessio Mario, in fondo c'è sempre il pubblico dei miei alunni! La prof.ssa D'Angelo
19 gennaio 2007
Algoritmi ricorsivi - terza parte
Un errore comune di programmazione è la ricorsione infinita: un metodo che chiama se stesso infinite volte. Ciò si verifica perché i valori del parametro non si semplificano oppure perché manca la clausola di chiusura per terminare.
Il calcolatore ha bisogno di una certa quantità di memoria di tipo stack per gestire ciascuna chiamata ricorsiva. Dopo un certo numero di chiamate la memoria disponibile per questo scopo puo’ esaurirsi, allora il programma termina automaticamente segnalando un errore di stack.
Algoritmi ricorsivi - seconda parte
In Java, un metodo può chiamare se stesso, purché la chiamata utilizzi un valore più semplice. Il meccanismo per cui un metodo chiama se stesso per un numero ripetuto di volte si chiama ricorsione.
Esaminiamo il calcolo di 4! con il metodo factorial.
Per calcolare il fattoriale di 4, il metodo factorial(4) chiede di calcolare 4 * factorial(3). Non sapendo il risultato, si sospende temporaneamente questo calcolo e si intraprende il calcolo di factorial(3).
Per calcolare factorial(3) dobbiamo calcolare 3 * factorial(2). Non sapendo nemmeno questo risultato, si tralascia temporaneamente anche questo problema e si risolve factorial(2).
Per calcolare factorial(2) dobbiamo prima calcolare factorial(1).
Per calcolare factorial(1) dobbiamo prima calcolare factorial(0).
Il metodo factorial(0) restituisce 1, e a questo punto possiamo completare i calcoli lasciati in sospeso.
Ecco la successione delle chiamate e dei valori restituiti:
factorial(4) chiama factorial(3)
factorial(3) chiama factorial(2)
factorial(2) chiama factorial(1)
factorial(1) chiama factorial(0)
factorial(0) restituisce 1
factorial(1) restituisce 1 (1*1)
factorial(2) restituisce 2 (2*1)
factorial(3) restituisce 6 (3*2)
factorial(4) restituisce 24 (4*6)
==================================================
La fine della ricorsione
Esistono due requisiti chiave per assicurarsi che la ricorsione riesca:
Ciascuna chiamata ricorsiva deve semplificare in qualche modo l'elaborazione. (Nel metodo factorial le chiamate ricorsive si fanno su parametri più piccoli.)
Il metodo deve prevedere una clausola di chiusura per assicurarsi che le chiamate successive del metodo abbiano termine, ovvero devono esistere casi speciali per risolvere le elaborazioni più semplici.(Nel metodo factorial, il valore del parametro giunge inevitabilmente a zero, ed esiste un caso speciale per risolvere 0!).
Esaminiamo il calcolo di 4! con il metodo factorial.
Per calcolare il fattoriale di 4, il metodo factorial(4) chiede di calcolare 4 * factorial(3). Non sapendo il risultato, si sospende temporaneamente questo calcolo e si intraprende il calcolo di factorial(3).
Per calcolare factorial(3) dobbiamo calcolare 3 * factorial(2). Non sapendo nemmeno questo risultato, si tralascia temporaneamente anche questo problema e si risolve factorial(2).
Per calcolare factorial(2) dobbiamo prima calcolare factorial(1).
Per calcolare factorial(1) dobbiamo prima calcolare factorial(0).
Il metodo factorial(0) restituisce 1, e a questo punto possiamo completare i calcoli lasciati in sospeso.
Ecco la successione delle chiamate e dei valori restituiti:
factorial(4) chiama factorial(3)
factorial(3) chiama factorial(2)
factorial(2) chiama factorial(1)
factorial(1) chiama factorial(0)
factorial(0) restituisce 1
factorial(1) restituisce 1 (1*1)
factorial(2) restituisce 2 (2*1)
factorial(3) restituisce 6 (3*2)
factorial(4) restituisce 24 (4*6)
==================================================
La fine della ricorsione
Esistono due requisiti chiave per assicurarsi che la ricorsione riesca:
Ciascuna chiamata ricorsiva deve semplificare in qualche modo l'elaborazione. (Nel metodo factorial le chiamate ricorsive si fanno su parametri più piccoli.)
Il metodo deve prevedere una clausola di chiusura per assicurarsi che le chiamate successive del metodo abbiano termine, ovvero devono esistere casi speciali per risolvere le elaborazioni più semplici.(Nel metodo factorial, il valore del parametro giunge inevitabilmente a zero, ed esiste un caso speciale per risolvere 0!).
Algoritmi ricorsivi in Java - Prima parte
Molti algoritmi presentano una struttura ricorsiva e, per risolvere un determinato problema, tali algoritmi richiamano se stessi più volte, per gestire sottoproblemi analoghi a quello di partenza.
Gli algoritmi ricorsivi generalmente sono organizzati nel seguente modo:
Il problema da risolvere è suddiviso in sottoproblemi simili a quello originale, ma di dimensione inferiore.
I sottoproblemi sono risolti ricorsivamente.
Se la dimensione dei sottoproblemi è sufficientemente piccola, essi sono invece risolti direttamente.
Le soluzioni dei sottoproblemi sono combinate per ottenere la soluzione del problema di partenza.
Un Esempio: La Funzione Fattoriale.
Immaginiamo di dover calcolare il fattoriale del numero n:
n! = 1 * 2 * 3 * ... * n
Cioè il fattoriale di 7 che si indica con 7! = 7*6*5*4*3*2*1
Per convenzione 0! = 1. Inoltre il fattoriale non è definito per i numeri negativi.
Come possiamo scrivere un metodo che calcoli la funzione fattoriale? Osserviamo che
n! = 1*2*...*(n-1)*n = (n-1)! * n
Quindi, un algoritmo per calcolare il fattoriale di n si può descrivere nel seguente modo:
per calcolare il fattoriale di n, si calcola il fattoriale di n-1 e lo si moltiplica per n.
Possiamo allora implementare il seguente metodo:
public static int factorial(int n)
{ if (n == 0)
return 1;
// calcolo diretto di 0!
else
{ int result = n * factorial(n - 1);
return result;
}
} // fine metodo factorial
28 novembre 2006
Codice Utile - Ordinamento BubbleSort Ottimizzato
public void Ordina(int n)
{ boolean Fattoscambio;
String Comodo;
int E=0;
do
{
Fattoscambio = false;
for(int i=0;i { if(Parole[i].compareTo(Parole[i+1])>0)
{ Comodo = Parole[i];
Parole[i] = Parole[i+1];
Parole[i+1] = Comodo;
Fattoscambio = true;
}
}
E = E+1;
}while(Fattoscambio==true);
}
{ boolean Fattoscambio;
String Comodo;
int E=0;
do
{
Fattoscambio = false;
for(int i=0;i
{ Comodo = Parole[i];
Parole[i] = Parole[i+1];
Parole[i+1] = Comodo;
Fattoscambio = true;
}
}
E = E+1;
}while(Fattoscambio==true);
}
17 luglio 2006
Codice Utile - Inviare Una Mail
/* Programma Semplice Per Inviare Una E-Mail. * **************************************************************************** * * ATTENZIONE: Per Funzionare Il Programma Necessita Delle Librerie: * * * 1) javax.mail * * * 2) javax.activation * * * Possono essere scaricate dal sito della Sun Microsystem(http://www.sun.it* * * oppure cercando su internet. * * **************************************************************************** * Autore: Alessio Mario. */
import java.io.*;
import javax.mail.*;
import javax.maio.internet.*;
import javax.activation.*;
import javax.swing.*;
public class Mail {
public static void send(String SmtpHost, int SmtpPort, String From, String To, String subject, String Content) throws AndressException, MessagingException
{ // Create A Mail Session
java.util.Properties props = new java.util.Properties();
props.put("mail.smtp.host",SmtpHost);
props.put("mail.smtp.port",SmtpPort);
Session session = Session.getDefaultInstance(props, null);
// Construct The Message
Message msg = new MimeMessage(session);
msg.setFrom(new InternetAndress(From));
msg.setRecipient(Message.RecipientType.TO, new Internet Andress(to));
msg.setSubject(Subject);
msg.setText(Content);
// Send The Message
Transport.send(msg);
}
public static void main(String[]args) throws Exception
{ // Messaggio Di Prova
send("hostname",25,"mario@tiscali.it","siravo@tiscali.it","re:ciao","Come Stai?"); } }
import java.io.*;
import javax.mail.*;
import javax.maio.internet.*;
import javax.activation.*;
import javax.swing.*;
public class Mail {
public static void send(String SmtpHost, int SmtpPort, String From, String To, String subject, String Content) throws AndressException, MessagingException
{ // Create A Mail Session
java.util.Properties props = new java.util.Properties();
props.put("mail.smtp.host",SmtpHost);
props.put("mail.smtp.port",SmtpPort);
Session session = Session.getDefaultInstance(props, null);
// Construct The Message
Message msg = new MimeMessage(session);
msg.setFrom(new InternetAndress(From));
msg.setRecipient(Message.RecipientType.TO, new Internet Andress(to));
msg.setSubject(Subject);
msg.setText(Content);
// Send The Message
Transport.send(msg);
}
public static void main(String[]args) throws Exception
{ // Messaggio Di Prova
send("hostname",25,"mario@tiscali.it","siravo@tiscali.it","re:ciao","Come Stai?"); } }
13 giugno 2006
Recupero dei dati da un file di testo
Come si fa a rileggere i dati depositati in un file di testo?
La linea è una stringa e quindi si fa usando i metodi sulle stringhe.
Alessio M. scriverà qui di seguito il pezzo di codice che lo fa. La Prof.
La linea è una stringa e quindi si fa usando i metodi sulle stringhe.
Alessio M. scriverà qui di seguito il pezzo di codice che lo fa. La Prof.
27 aprile 2006
Operazioni Di I/O Su File Di Testo
OPERAZIONI POSSIBILI SU UN FILE DI TESTO:
1) Apertura File:
In questa Fase Molto Importante Viene Comunicato Al Sistema Il Nome Del File Da Creare e La Sua Posizione Sull' Hard-Disk. Esempio:
================================================
FileWriter FileNoBuffer = new FileWriter("c:\esercizijava\NomeFile.txt",true);
BufferedWriter FileOutput = new BufferedWriter(FileNoBuffer);
================================================
In Questo Segmento Di Programma Creiamo Un File Di Testo Non "Bufferizzato" con la Classe
FileWriter. L'opzione true Serve A Comunicare alla JVM Di non Cancellare I Record Presenti Nel File con quelli nuovi Ma Di Accodare quelli nuovi, Se il true Viene Omesso I Record vecchi Verranno persi perchè Automaticamente Sovrascritti.
Per "Bufferizzare" Il File Usiamo la classe BufferedWriter.
NB: Questo Segmento Va Usato SOLAMENTE Per SCRIVERE su un File, Mentre Per La Lettura Si Usa Un Altro gruppo di istruzioni Spiegato Successivamente.
2) Scrivere Su Un File:
Per Scrivere Una Linea Su Un File di testo bisogna Usare Il Metodo write(). Esempio:
==============================================
FileOutput.write();
FileOutput.newLine();
==============================================
Il Metodo newLine() Serve A "andare a capo" sul file.
3) Chiusura Di Un File
Chiudere Un File è IMPORTANTISSIMO, Pena La Cancellazione Del File Stesso.
Per Chiudere Correttamente Un File Si Usa Il Metodo close(). Esempio:
==============================================
FileOutput.close();
==============================================
4) Lettura Di Un File
Per Leggere Un File Si Usa Un gruppo di istruzuioni Simile a quello che abbiamo usato per l'apertura Ma Con Alcune Varianti.
Si Usa la classe FileReader Per Impostare Il File Da Leggere E Leggerlo Successivamente. Il File Naturalmente Deve Essere " Bufferizzato" Quindi Si Usa la classe BufferReader. Esempio:
==============================================
FileReader FileX = new FileReader(" File.txt ");
BufferedReader FileInput = new BufferedReader(FileX);
Linea = FileInput.readLine();
while(Linea!=null)
{
s.o.p(""+Linea);
Linea = FileInput.readLine();
}
FileInput.close();
==============================================
Questo Segmento Legge Il Contenuto Del File Linea Per Linea Fino A Che Non si Incontra Una Linea Vuota (uguale a null) Che indica La Fine Del File. Successivamente Viene Chiuso Il File.
Per Ulteriori Informazioni riguardo ai programmi sui file di testo Visitate Il Sito http:\\www.meatim.it alla voce "Didattica" e poi "Esercizi Java".
Autore Post: Alessio M.
1) Apertura File:
In questa Fase Molto Importante Viene Comunicato Al Sistema Il Nome Del File Da Creare e La Sua Posizione Sull' Hard-Disk. Esempio:
================================================
FileWriter FileNoBuffer = new FileWriter("c:\esercizijava\NomeFile.txt",true);
BufferedWriter FileOutput = new BufferedWriter(FileNoBuffer);
================================================
In Questo Segmento Di Programma Creiamo Un File Di Testo Non "Bufferizzato" con la Classe
FileWriter. L'opzione true Serve A Comunicare alla JVM Di non Cancellare I Record Presenti Nel File con quelli nuovi Ma Di Accodare quelli nuovi, Se il true Viene Omesso I Record vecchi Verranno persi perchè Automaticamente Sovrascritti.
Per "Bufferizzare" Il File Usiamo la classe BufferedWriter.
NB: Questo Segmento Va Usato SOLAMENTE Per SCRIVERE su un File, Mentre Per La Lettura Si Usa Un Altro gruppo di istruzioni Spiegato Successivamente.
2) Scrivere Su Un File:
Per Scrivere Una Linea Su Un File di testo bisogna Usare Il Metodo write(). Esempio:
==============================================
FileOutput.write();
FileOutput.newLine();
==============================================
Il Metodo newLine() Serve A "andare a capo" sul file.
3) Chiusura Di Un File
Chiudere Un File è IMPORTANTISSIMO, Pena La Cancellazione Del File Stesso.
Per Chiudere Correttamente Un File Si Usa Il Metodo close(). Esempio:
==============================================
FileOutput.close();
==============================================
4) Lettura Di Un File
Per Leggere Un File Si Usa Un gruppo di istruzuioni Simile a quello che abbiamo usato per l'apertura Ma Con Alcune Varianti.
Si Usa la classe FileReader Per Impostare Il File Da Leggere E Leggerlo Successivamente. Il File Naturalmente Deve Essere " Bufferizzato" Quindi Si Usa la classe BufferReader. Esempio:
==============================================
FileReader FileX = new FileReader(" File.txt ");
BufferedReader FileInput = new BufferedReader(FileX);
Linea = FileInput.readLine();
while(Linea!=null)
{
s.o.p(""+Linea);
Linea = FileInput.readLine();
}
FileInput.close();
==============================================
Questo Segmento Legge Il Contenuto Del File Linea Per Linea Fino A Che Non si Incontra Una Linea Vuota (uguale a null) Che indica La Fine Del File. Successivamente Viene Chiuso Il File.
Per Ulteriori Informazioni riguardo ai programmi sui file di testo Visitate Il Sito http:\\www.meatim.it alla voce "Didattica" e poi "Esercizi Java".
Autore Post: Alessio M.
19 aprile 2006
Codice Utile - Uso Del Metodo Length()
Il Metodo Length() è un Metodo Che fa riferimento alla classe String Implementata in Java.
Il suo utilizzo è molto semplice e permette di conoscere la lunghezza di una stringa.
Esempio:
-----------------------------------------------------------------------
Metodo Main
....
....
String Nome = sop(" Inserisci Il Tuo Nome: ");
int Lung = Nome.length();
sop(" Il Tuo Nome e' Lungo: "+Lung+ " Caratteri.");
------------------------------------------------------------------------
Questo Pezzo Di programma Rileva Da Quante lettere è composto il nome inserito dall'utente e poi ne visualizza il numero.
Cosa molto importante è quella di inserire il nome dell'oggetto davanti al metodo altrimenti La JVM non saprà dove applicare il metodo Length (che non è un Metodo statico).
Autore: Alessio M.
Il suo utilizzo è molto semplice e permette di conoscere la lunghezza di una stringa.
Esempio:
-----------------------------------------------------------------------
Metodo Main
....
....
String Nome = sop(" Inserisci Il Tuo Nome: ");
int Lung = Nome.length();
sop(" Il Tuo Nome e' Lungo: "+Lung+ " Caratteri.");
------------------------------------------------------------------------
Questo Pezzo Di programma Rileva Da Quante lettere è composto il nome inserito dall'utente e poi ne visualizza il numero.
Cosa molto importante è quella di inserire il nome dell'oggetto davanti al metodo altrimenti La JVM non saprà dove applicare il metodo Length (che non è un Metodo statico).
Autore: Alessio M.
12 aprile 2006
Codice Utile - Uso Del JOptionPane
In questo post Vorrei Parlarvi dela classe JOptionPane.
Queste informazioni potrebbero essere utili a tutti quei programmatori che si sono stufati del classico schermo nero con testo bianco per i loro programmi, infatti la JOptionPane serve a creare programmi con un'interfaccia a Box Grafici!.
L'uso è veramente semplice.
Prima di cominciare ad illustrare il funzionamento di essa vorrei comunicarvi che esistono 2 metodi da usare, il primo serve per far stampare un messaggio, l'altro per far inserire all'utente un dato:
JOptionPane.showMessageDialog(null,"Testo: "); // Fuori il messaggio
JOptionPane.showInputDialog(null,"Introduci l'importo: "); // In ingresso l'importo
Altra cosa fondamentale è importare le libreria di questa funzione con
import javax.swing.*; infatti è la libreria Swing.
Ora Vi mostrerò un Segmento Di Codice Che Fa Inserire all'Utente un testo e lo visualizza sullo schermo:
NB: JOP = JOptionPane
import javax.swing.*;
// class......
// Main......
String Nome = JOP.showInputDialog(null," Dammi il tuo nome:");
JOP.showMessageDialog(null,"Ciao "+NOme);
Invece per far entrare in ingresso un numero intero:
int num= Integer.parseInt(JOP.showInputDialog(null,"Introduci un numero intero: ");
Autore: Alessio M.
Queste informazioni potrebbero essere utili a tutti quei programmatori che si sono stufati del classico schermo nero con testo bianco per i loro programmi, infatti la JOptionPane serve a creare programmi con un'interfaccia a Box Grafici!.
L'uso è veramente semplice.
Prima di cominciare ad illustrare il funzionamento di essa vorrei comunicarvi che esistono 2 metodi da usare, il primo serve per far stampare un messaggio, l'altro per far inserire all'utente un dato:
JOptionPane.showMessageDialog(null,"Testo: "); // Fuori il messaggio
JOptionPane.showInputDialog(null,"Introduci l'importo: "); // In ingresso l'importo
Altra cosa fondamentale è importare le libreria di questa funzione con
import javax.swing.*; infatti è la libreria Swing.
Ora Vi mostrerò un Segmento Di Codice Che Fa Inserire all'Utente un testo e lo visualizza sullo schermo:
NB: JOP = JOptionPane
import javax.swing.*;
// class......
// Main......
String Nome = JOP.showInputDialog(null," Dammi il tuo nome:");
JOP.showMessageDialog(null,"Ciao "+NOme);
Invece per far entrare in ingresso un numero intero:
int num= Integer.parseInt(JOP.showInputDialog(null,"Introduci un numero intero: ");
Autore: Alessio M.
Codice Utile - Uso Del Ciclo Di Controllo
Da questo post in poi ogni tanto introdurrò alcuni "segmenti" di codice scritti in Java con cui potete svolgere diverse utili funzioni. Ogni segmento è accompagnato da una spiegazione.
Vorrei iniziare con il controllo su un numero in entrata.
Quante volte accade che un utente distratto inserisca dei valori non consentiti in un programma? Molte volte, e per risolvere questo problema si può utilizzare un ciclo chiamato While che blocca l'utente distratto e lo costringe a reinserire il valore:
System.out.println (" Inserisci un numero intero non nullo, nè negativo e inferiore a 100: ");
int Num = Integer.parseInt(tastiera.readLine());
while (Num<=0 Num>=100) // sta per OR (è il carattere di pipe line doppio)
{ System.out.println(" Numero non consentito, reinserirlo tra 1 e 100");
Num = Integer.parseInt(tastiera.readLine());
}
Spiegazione:
Per prima cosa salviamo il valore inserito dentro una variabile di tipo inetro e successivamente attiviamo il ciclo while che come condizione ha quella composta da due sottocondizioni legate dall'operatore logico OR che in Java si scrive come un doppio carattere di pipe line.
Se è errato allora dentro il ciclo avvertiamo l'utente che ha inserito un valore non consentito e gli chiediamo di reinserirlo per ricontrollarlo di nuovo.
Il ciclo può non finire mai se l'utente non corregge il suo errore!
Autore: Alessio M.
Vorrei iniziare con il controllo su un numero in entrata.
Quante volte accade che un utente distratto inserisca dei valori non consentiti in un programma? Molte volte, e per risolvere questo problema si può utilizzare un ciclo chiamato While che blocca l'utente distratto e lo costringe a reinserire il valore:
System.out.println (" Inserisci un numero intero non nullo, nè negativo e inferiore a 100: ");
int Num = Integer.parseInt(tastiera.readLine());
while (Num<=0 Num>=100) // sta per OR (è il carattere di pipe line doppio)
{ System.out.println(" Numero non consentito, reinserirlo tra 1 e 100");
Num = Integer.parseInt(tastiera.readLine());
}
Spiegazione:
Per prima cosa salviamo il valore inserito dentro una variabile di tipo inetro e successivamente attiviamo il ciclo while che come condizione ha quella composta da due sottocondizioni legate dall'operatore logico OR che in Java si scrive come un doppio carattere di pipe line.
Se è errato allora dentro il ciclo avvertiamo l'utente che ha inserito un valore non consentito e gli chiediamo di reinserirlo per ricontrollarlo di nuovo.
Il ciclo può non finire mai se l'utente non corregge il suo errore!
Autore: Alessio M.
Iscriviti a:
Post (Atom)