edutecnica
 


Metodi

Per dirla in una maniera molto 'sportiva' i metodi, concettualmente, sono la stessa cosa delle funzioni in linguaggio C, delle procedure in linguaggio Pascal o delle subroutines in linguaggio Basic. Cioè dei sottoprogrammi. In pratica degli algoritmi che ricevono un input e restituiscono un output.

Come nel caso del linguaggio C, è possibile ignorare completamente i canoni della programmazione ad oggetti ed usare Java in modo completamente procedurale , utilizzando metodi statici.

In pratica, possiamo riscrivere tutti i listati scritti in C++ visti in precedenza semplicemente facendo precedere il modificatore static al metodo (funzione) utilizzato.

Qui notiamo un semplice programma per il calcolo dell'area di un cerchio, già svolto in linguaggio C

import java.io.*;
class metodoStatico {
public static void main (String args []) throws IOException {

InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);

double area,raggio;
System.out.print("raggio:");
raggio=Integer.parseInt(h.readLine().trim());
area=sup(raggio);
System.out.println("area:"+area);
}//fine main
static double sup(double ray){
return ray*ray*Math.PI;
}//fine sup }// fine classe


Notiamo come non sia indispensabile l'uso del prototipo.

Il passaggio dei parametri avviene sempre per valore nel caso delle variabili , mentre avviene sempre per indirizzo nel caso degli oggetti; quindi anche nel caso dei vettori e delle stringhe, dato che in Java i vettori e stringhe sono oggetti.

Oltre ai metodi statici esistono anche attributi statici denominati anche variabili di classe, in contrapposizione agli attributi non statici denominati anche variabili d'istanza.

Una variabile static viene inizializzata solo la prima volta che si esegue la funzione in cui è presente e alla fine di tale funzione non viene "cancellata": il suo valore rimane in memoria, quindi la seconda volta che chiami la funzione essa avrà il valore che le era stato dato in precedenza.

Vettori

Un vettore è una struttura di dati omogenei (dello stesso tipo) memorizzati in locazioni contigue di memoria. Ognuno dei valori è memorizzato in una locazione del vettore . Per accedere a ogni locazione si usa un indice (un valore numerico): la prima locazione ha indice 0, la seconda 1 e così via . Ad es.

int A[];//dichiarazione
A = new int[5];//allocazione

Definisce un vettore di 5 numeri interi.
Spesso dichiarazione e allocazione vengono effettuate insieme:

int A[] = new int[5];

È inoltre possibile assegnare, all 'atto della dichiarazione-allocazione, i valori iniziali del vettore (inizializzazione):

int A[]={2, 9, 4, 7, 3};

La lunghezza di un vettore (il numero di elementi) è ottenibile posponendo al nome del vettore un punto e la parola length.

System.out.println(A. length);

restituisce 5 in output. È ovvio che l'indicizzazione del vettore avviene tra 0 e A.length-1 . In ragione di ciò è possibile eseguire la scansione del vettore, tramite il ciclo for, evitando la dichiarazione di una costante globale che contenga il numero di elementi del vettore.

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

Come esempio riportiamo il caricamento da programma di un vettore

class caricamentoDaProgramma {
public static void main (String[] args) {
int i; int A[]={2,9,4,7,3};
//stampa
for(i=0;i < A.length;i++)System.out.print(" "+A[i]);
}//fine main
}//fine class


In questo listato, il caricamento random con interi da 1 a 9 compresi:

class caricamentoRandom{
public static void main (String[] args) {
int i; int A[] = new int[5]; //caricamento
for(i=0;i < A.length;i++)
A[i]=(1+(int)(Math.random()* 9));
//stampa
for(i=0;i < A.length;i++)System.out.print(" "+A[i]);
}//fine main
}//fine class


In questo listato, il caricamento da tastiera:

import java.io.*;
class caricamentoTastiera {
public static void main (String[] args) throws IOException {
int i;
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
//int[] A = new int[5];//dichiarazione alternativa
int A[] = new int[5];
//caricamento
for(i=0;i < A.length;i++){
     System.out.print("ins "+(i+1)+"°:");
     A[i]=Integer.parseInt(h.readLine().trim());
}//fine for
//stampa
for(i=0;i < A.length;i++)System.out.print(" "+A[i]);
}//fine main
}//fine class


Matrici

Una matrice è un vettore a due dimensioni costituito da un cero numero di righe e di colonne. Noi indicizziamo le righe con la variabile i e le colonne con la j.


Per dichiarare la seguente matrice a 4 righe e 3 colonne usiamo:

int A[][] = new int[4][3];

l'accesso ad ogni elemento avviene tramite la sintassi

A[indiceRiga][indiceColonna]

La creazione/allocazione/inizializzazione può essere fatta così:

int A[][]={{1,2,3},{4,5,6},{7,8,9},{10,11,12}};

Bisogna ricordarsi che la scansione della matrice avviene tecnicamente, usando due cicli for annidati come emerge dal seguente listato che illustra il caricamento da tastiera di una matrice 3x3;

import java.io.*;
class matriceTastiera {
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
int i,j;
int A[][]= new int[3][3];
//caricamento
for(i=0;i < A.length;i++)
      for(j=0;j < A.length;j++){
           System.out.print("riga:"+(i+1)+" colonna "+(j+1)+":");
           A[i][j]=Integer.parseInt(h.readLine().trim());
       }//fine for j
//stampa
for(i=0;i < A.length;i++){
     for(j=0;j < A.length;j++)System.out.print(A[i][j]+" ");
     System.out.println();
}//fine for i
}//fine main
}// fine classe


Qui il caricamento random di una matrice 4x3

class matriceRandom{
public static void main (String[] args) {
int i,j; int A[][]= new int[4][3];
//caricamento
for(i=0;i < A.length;i++)
     for(j=0;j < A[0].length;j++)A[i][j]=(1+(int)(Math.random()* 9));
//stampa
for(i=0;i < A.length;i++){
     for(j=0;j < A[0].length;j++)System.out.print(A[i][j]+" ");
     System.out.println();
}//fine for i
}//fine main
}//fine class


Notare come la l'altezza della matrice sia stata dedotta con l'istruzione A[0].length

Stringhe

Una stringa è formata da una lista lineare di caratteri racchiusa fra due coppie di doppi apici; in Java è gestita dalla classe String. Data l'importanza di questo tipo di dato, si possono dichiarare nuovi oggetti stringa senza usare l'operatore new.

La dichiarazione può avvenire una sintassi simile alle dichiarazione dei tipi di dati primitivi:

String str="ciao a tutti" ;
System.out.println(str);


o con una sintassi più formale simile alla dichiarazione dei vettori:

String str=new String("ciao a tutti");

E' già noto l'operatore '+' usato per concatenare più stringhe; di seguito è riportato un elenco di metodi per la classe String.

selezione char charAt(int i) Ritorna il carattere con indice i.
String substring(int start, int stop) Ritorna una sottostringa.
confronto int length() Restituisce la lunghezza della stringa.
int compareTo(String s) Compara due stringhe.
boolean equals(Object o) Confronta la stringa attuale con l'oggetto specificato.
concatenazione String concat(String s) Concatena la stringa argomento alla stringa attuale.
ricerca int indexOf(char ch) Ritorna l'indice della prima occorrenza del carattere indicato.
int indexOf(int ch, int i) Ritorna l'indice interno alla stringa della prima occorrenza del carattere
specificato, facendo partire la ricerca dall'indice i.
int indexOf(String s) Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s.
int indexOf(String s, int i) Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s, a partire dall'indice i specificato.
conversione char[] toCharArray() Converte la stringa in un vettore di caratteri.
String toLowerCase() Converte tutti i caratteri della stringa in minuscolo.
String toUpperCase() Converte tutti i caratteri della stringa in maiuscolo.
String trim() elimina gli spazi iniziali e finali.
sostituzione String replace(char oldCh, char newCh) Ritorna una nuova stringa dove tutte le occorrenze di vCh sono sostituite con nCh.
String replaceAll(String regExp, String s) Sostituisce ogni sottostringa di questa stringa corrispondente all'espressione regolare data.
String replaceFirst(String regExp, String s) Sostituisce la prima sottostringa di questa stringa che corrisponde all'espressione regolare data.

Conversione da stringa a numero
Byte.parseByte(s.trim())
Short.parseShort(s.trim())
Integer.parseInt(s.trim())
Long.parseLong(s.trim())
Short.parseShort(s.trim())
Float.parseFloat(s.trim())
Double.parseDouble(s.trim())

Conversione da numero a stringa
modo 1 modo 2
Byte.toString(b) String.valueOf(b)
Short.toString(s) String.valueOf(s)
Integer.toString(i) String.valueOf(i)
Long.toString(l) String.valueOf(l)
Float.toString(f) String.valueOf(f)
Double.toString(d) String.valueOf(d)


char charAt(int i)

Questo metodo ritorna il carattere alla posizione specificata dall'indice.
public class prova {
public static void main(String args[]) {
     String s = "innumerevoli stringhe";
     char ch = s.charAt(8); System.out.println(ch);
     }
}


String substring(int start) o String substring(int start, int stop)
Ritorna una sottostringa che parte dall'indice start incluso all'indice stop escluso
class prova {
public static void main (String args []) {
String Str = new String("alpha beta gamma");
System.out.print("valore di ritorno:" );
System.out.println(Str.substring(6) );
System.out.print("valore di ritorno:" );
System.out.println(Str.substring(6, 10));
}//fine main
}// fine classe


int length()
Restituisce la lunghezza di una stringa
class prova {
public static void main (String args []) {
String Str1 = new String("alpha beta gamma delta");
String Str2 = new String("alpha omega" );
System.out.print("lunghezza stringa :" );
System.out.println(Str1.length());
System.out.print("lunghezza stringa :" );
System.out.println(Str2.length());
}//fine main
}// fine classe


int compareTo(Object o) o int compareTo(String s)
Compara la corrente stringa oggetto (this) con quella argomento s.
Restituisce 0 se sono uguali.
Restituisce un int < 0 se this < s.
Restituisce un int > 0 se this > s.
class prova {
public static void main (String args []) {
String str1 = "alpha omega";
String str2 = "alpha omega";
String str3 = "alpha beta gamma delta";
int risultato = str1.compareTo( str2 );
System.out.println(risultato);
risultato = str2.compareTo( str3 );
System.out.println(risultato);
risultato = str3.compareTo( str1 );
System.out.println(risultato);
}//fine main
}// fine classe


boolean equals(Object o)
Il metodo compara la stringa attuale con l'oggetto specificato. Ritorna true se e solo se l'argomento non è nullo ed è una stringa che rappresenta la stessa sequenza di quella corrente.
class prova {
public static void main (String args []) {
String Str1 = new String("alpha beta");
String Str2 = Str1;
String Str3 = new String("alpha beta omega");
boolean risultato; risultato = Str1.equals( Str2 );
System.out.println("valore di ritorno = " + risultato );
risultato = Str1.equals( Str3 );
System.out.println("valore di ritorno = " + risultato);
}//fine main
}// fine classe


int indexOf(char ch)
Ritorna l'indice della prima occorrenza del carattere indicato, oppure, ritorna -1 se il carattere non viene trovato.
int indexOf(int ch, int i)
Ritorna l'indice interno alla stringa della prima occorrenza del carattere specificato, facendo partire la ricerca dall'indice i o da -1 se il carattere non viene individuato.
int indexOf(String s)
Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s. Se non viene individuta s, il metodo restituisce -1.
int indexOf(String s)
Ritorna l'indice interno alla stringa corrente alla prima occorrenza della (eventuale) sottostringa s, a partire dall'indice i specificato. Se non vi è occorrenza di s, viene restitituito -1.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
String s1 = new String("edu");
String s2 = new String("tecnica");
System.out.print("index :" );
System.out.println(s.indexOf( 'e' ));
System.out.print("index :" );
System.out.println(s.indexOf( 'e', 10 ));
System.out.print("index :" );
System.out.println( s.indexOf( s1 ));
System.out.print("index :" );
System.out.println( s.indexOf( s1, 15 ));
System.out.print("index :" );
System.out.println(s.indexOf( s2 ));
}//fine main
}// fine classe


char[] toCharArray()
Converte la stringa in un vettore di caratteri
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato :" );
System.out.println(s.toCharArray() );
}//fine main
}// fine classe


String toLowerCase()
Converte tutti i caratteri della stringa in minuscolo
class prova {
public static void main (String args []) {
String s = new String("Benvenuto Ad Edutecnica");
System.out.print("risultato :");
System.out.println(s.toLowerCase());
}//fine main
}// fine classe


String toUpperCase()

Converte tutti i caratteri della stringa in maiuscolo.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto Ad Edutecnica");
System.out.print("risultato :");
System.out.println(s.toUpperCase());
}//fine main
}// fine classe


String replace(char oldCh, char newCh)
Ritorna una nuova stringa dove tutte le occorrenze di oldCh sono sostituite con newCh.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato :" );
System.out.println(s.replace('e', 'X'));
System.out.print("risultato :" );
System.out.println(s.replace('t', 'T'));
}//fine main
}// fine classe


String replaceAll(String regExp, String s)
Sostituisce ogni sottostringa della stringa attuale corrispondente all'espressione regolare data.

Le epressioni regolari (regEx) sono una sintassi per descrivere la morfologia di una stringa .
Se il testo contenuto è testo semplice verrà ricercata esattamente quella sequenza di caratteri (con distinzione fra maiuscole e minuscole). Esistono caratteri particolari che se inseriti all'interno della regEx hanno un significato particolare:

[ ] "parentesi quadre" tutti gli eventuali caratteri all'interno delle [ ].

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[ea]","_" ));
//restituisce: bXnvXnuto Xd EdutXcnicX


si possono definire intervalli:
[a-z] tutti i caratteri minuscoli
[0-9] tutte le cifre
[a-zA-Z] tutti i caratteri minuscoli o maiuscoli

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[A-Z]","X" ));
//restituisce: benvenuto ad Xdutecnica


^ "accento circonflesso" : nelle parentesi quadre definisce delle esclusioni:
[^o] qualsiasi carattere diverso da 'o'
[^a-z] qualsiasi carattere diverso da una minuscola
[^ea] qualsiasi carattere diverso da 'a' e da 'e'

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("[^aeiouAEIOU]","X" ));
//restituisce: XeXXeXuXoXaXXEXuXeXXiXa


| operatore OR di alternativa

String s = new String("benvenuto ad Edutecnica");
System.out.println(s.replaceAll("ben|E","X" ));
//restituisce: Xvenuto ad Xdutecnica


Cioè intercetta la lettera 'E' o la stringa 'ben'. Qui non possono essere usate le [] altrimenti verrebbero intercettate le lettere 'b','e','n' ed 'E'.

? "punto di domanda" il carattere precedente a ? è opzionale (ricorre 0 o 1 volta)

String s = new String("nafta nata Nafta");
System.out.println(s.replaceAll("naf?ta","X" ));
\\restituisce:X X Nafta


* "asterisco" accetta 0 o n ripetizioni del carattere precedente a *
Ad es. il carattere '1' seguito da 0 o n '2'

String s = new String("cifre 1 1222 3122245 cifre");
System.out.println(s.replaceAll("12*","X" ));
//restituisce: cifre X X 3X45 cifre


+ "più" più accetta 1 o n ripetizioni del carattere precedente al +
Ad es. il carattere '1' seguito da 1 o n '2'.

String s = new String("cifre 1 1222 3122245 cifre");
System.out.println(s.replaceAll("12+","X" ));
//restituisce: cifre 1 X 3X45 cifre


Ovviamente nel caso di replaceAll, l'operazione più remunerativa, è la ricerca e la sostituzione di una stringa in una frase.

class prova{
public static void main (String[] args) {
String s = new String("tanto va la gatta al lardo che il lardo zampina");
System.out.println(s.replaceAll("lardo", "gatto" ));
}//fine main
}//fine class


più in generale, con input output da tastiera:

import java.io.*;
class prova{
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
String st,s1,s2;
System.out.print("frase:");
st=h.readLine();
System.out.print("sottostringa da cercare:");
s1=h.readLine();
System.out.print("sottostringa sostitutiva:");
s2=h.readLine();
st=st.replaceAll(s1,s2);
System.out.println(st);
}//fine main
}// fine classe

String replaceFirst(String regExp, String s)
Sostituisce la prima sottostringa della stringa attuale che corrisponde all'espressione regolare data.
class prova {
public static void main (String args []) {
String s = new String("Benvenuto ad edutecnica");
System.out.print("risultato:" );
System.out.println(s.replaceFirst("(.*)edu","Fisio" ));
System.out.print("risultato:" );
System.out.println(s.replaceFirst("tecnica", "Fisio" ));
}//fine main
}// fine classe


StringBuffer

E', inoltre, a disposizione il tipo StringBuffer che attraverso i suoi metodi consente di considerare la stringa alla stessa maniera di un vettore di caratteri. La sintassi della sua dichiarazione è:

StringBuffer s = new StringBuffer("star");

Per tale oggetto è a disposizione un'utile famiglia di metodi:

append(tipo d) aggiunge in coda una rappresentazione a stringa del dato d.
insert(int i, tipo d) inserisce all'indice i una rappresentazione a stringa del dato d.
delete(int i,int f) cancella i dati a partire da i fino a f.
deleteCharAt(int i) cancella il carattere in posizione i
replace(int i,int f, String s) cancella i dati a partire da i fino a f e poi inserisce s da i.
reverse() inverte la stringa.
setCharAt(int i, char ch) sovrascrive il carattere in posizione i con c
setLength(int lg) imposta la dimensione della stringa a lg

La differenza concettuale fra String e StringBuffer è che la prima è una classe per oggetti immutabili (una volta creati, non possono più essere modificati) mentre un oggetto di tipo StringBuffer è una stringa variabile nel contenuto e nella dimensione.

import java.io.*;
class provaBuffer {
public static void main (String args []) throws IOException {
InputStreamReader input=new InputStreamReader(System.in);
BufferedReader h= new BufferedReader(input);
String st;
StringBuffer sb=new StringBuffer();
System.out.print("vai:");
st=h.readLine();
sb.append("info= ");
sb.append(st);
sb.append(" inserito da tastiera");
st=sb.toString();
System.out.println(st);
}//fine main
}// fine classe


Viene qui usato il metodo toString() appartenente alla classe Object (da cui sono derivati tutti gli altri oggetti comprese le stringhe) per descrivere un oggetto come stringa.

 


edutecnica