I Metodi In Java

In tutti i linguaggi di programmazione è si può definire un insieme di istruzioni, identificale con un nome, in modo da poterle richiamare, tramite esso, in qualsiasi punto del programma. In questo modo otteniamo un codice riutilizzabile, senza doverlo riscrivere quelle istruzioni ogni volta. Questo insieme di istruzioni viene chiamato metodo.

Continua a leggere

La Ricorsione in Java

La ricorsione è una tecnica di programmazione che permette di creare dei metodi ricorsivi, ossia dei metodi che, durante la loro esecuzione, chiamano, direttamente o indirettamente, se stessi.

Quando un metodo invoca sè stesso, la JVM esegue le seguenti azioni:

  1. sospende l’esecuzione del metodo invocante
  2. esegue il metodo invocato fino alla sua conclusione
  3. riprende l’esecuzione del metodo invocante dal punto in cui era stata sospeso.

Per poter applicare questa tecnica, si deve decomporre un problema in problemi dello stesso tipo (cioè della stessa natura) ma di dimensione più piccola.

Continua a leggere

Modificatori Di Visibilità In Java

Modificatore Effetto
Publicvisibile da qualsiasi parte del programma
Privatevisibile solo all’interno della stessa classe
Protectedvisibile solo dalle classi dello stesso package e da tutte le sottoclassi
Defaultvisibile dallo stesso package e dalle sottoclassi se sono nello
stesso package. È la visibilità assegnata di default se non viene specificato nulla.

Le Classi In Java

Una classe in Java si definisce tramite la parola chiave class.

	public class MiaClasse {
		//variabili
		// metodi		
	}

All’interno del corpo della classe, ossia tra le parentesi graffe, si definiscono i vari metodi e variabili.

La regola fondamentale è che in ogni file .java deve avere al massimo una classe con la parola chiave public. Per quanto riguarda le regole di naming delle variabili e metodi, tutti nomi di classi devono iniziare per lettera maiuscola (così come le lettere iniziali delle parole composte), mentre i nomi di variabili e di metodi devono iniziare con la prima lettera minuscola e con le parole composte con le iniziali maiuscole.

Cenni Sulla Programmazione Orientata agli Oggetti (OOP)

I linguaggi di programmazione servono per creare dei modelli, delle astrazioni che descrivono il comportamento di un sistema reale.

Una possibile distinzione dei linguaggi di programmazione è tra i linguaggi procedurali e i linguaggi Orientati agli Oggetti (OOP). I linguaggi procedurali consentono di costruire modelli che privilegiano l’aspetto procedurale, cioè le operazioni (funzioni) che il sistema deve eseguire. I linguaggi di programmazione OOP consentono, invece, di costruire modelli che privilegiano le entità logiche, ossia il sistema viene suddiviso in una serie di componenti logici che interagiscono tra loro; ogni componente a sua volta è suddiviso in un insieme di attributi e in un insieme di operazioni, che in qualche modo riguardano il componente stesso.

Un componente nel mondo reale potrebbe essere la macchina di Franco, la macchina di Gigi, la casa di Giuseppe. Un componente è anche detto oggetto.

Continua a leggere

Array in Java

E’ possibile avere una lista di valori associati ad una variabile. Una variabile cosi composta si chiama Array. Un array (anche detto vettore) è un gruppo di elementi che viene dichiarato inizialmente specificandone la dimensione. La sintassi per la dichiarazione di una variabile di tipo array è la seguente:

TipoArray[]   nome = new TipoArray [n];

o anche:

TipoArray  nome[]= new TipoArray [n];

TipoArray  può essere sia un tipo primitivo che  una classe. “n” indica che l’array può contenere fino ad un massimo di n elementi di tipo TipoArray.

Continua a leggere

Java Syncronized: Come si usa esempio

Java Syncronized: Cos’è

Ad ogni oggetto (o anche ad un pezzo di codice) si può associare un semaforo (un lock). Ogni semaforo ha due operazioni: Get e Release. Quando un thread accede ad una zona critica tenta di prendere possesso del semaforo (Get); se non ci riesce verrà messo a dormire e ci ritenterà fino a quando un altro thread rilascerà (Release) tale semaforo.
Questi “semafori” in java vengono introdotti con la parola chiave “syncronized“. Si possono sincronizzare sia classi che metodi.
Quando un thread vuole accedere ad un metodo/blocco synchronized, deve acquisire il lock dell’oggetto (impedendo così l’accesso ad ogni altro thread).  Il lock viene automaticamente rilasciato quando il thread esce dal metodo/blocco synchronized(o se viene interrotto da un’eccezione).
Un thread che non riesce ad acquisire un lock rimane sospeso sulla richiesta della risorsa fino a che il lock non è disponibile. Ad ogni oggetto viene assegnato un solo lock: due thread non possono accedere contemporaneamente a due metodi/blocchi synchronized diversi di uno stesso oggetto.Tuttavia altri thread sono liberi di accedere a metodi/blocchi non synchronized associati allo stesso oggetto.

Java Syncronized: Esempio

Continua a leggere

Java HashMap – Esempio Collisione

Per poter usare correttamente l’HashMap bisogna implementare correttamente l’override delle funzioni hashcode() e equals() altrimenti si incorre nel problema delle collisioni, ossia per due chiavi diverse che hanno lo stesso hashcode,e quindi andranno nella stessa locazione,  non ci sarà modo di capire se si devono essere sovrascritti o aggiunti in quella locazione.

Per risolvere questo problema si deve fare l’override di haschcode (in modo da ridurre al minimo la possibilità che due chiavi diverse abbiano lo stesso hash) e anche di equals.In questo modo quando due chiavi diverse (due chiavi associati a due valori diversi) hanno lo stesso hashcode  viene utilizzata la  funzione equals per capire se è la stessa chiave o no. Se è la stessa chiave, viene aggiornata la coppia chiave-valore (ricordiamoci che nella locazione vengono inserite le coppie chiavi-valori), altrimenti viene aggiunta.

Vediamo un esempio che mostra un caso di hashmap con collisione risolto tramite l’equals:

Esempio:

Definiamo una classe Persona in cui l override di hashcode è fatto in modo tale che ritorni l’id.


package example.hashmap;

public class Persona {
private String nome;
private int id;

public Persona(String nome, int id) {
this.nome = nome;
this.id = id;
}

public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}

@Override
public int hashCode() {

System.out.println("chiamato hashCode per ="+ id+"."+nome);
return id;
}

@Override
public boolean equals(Object obj) {
System.out.println("called equals on ="+ id+"."+nome + " to compare with = "+ ((Persona)obj).getId() + "."+ ((Persona)obj).getNome());

if( ((Persona)obj).getId() == id && ((Persona)obj).getNome().equals(nome) )
return true;
return false;
}
}

Nel main, vengono create 3 chiavi, di cui due i (p1 e p3)  hanno lo stesso id (1), quindi lo stesso hashcode, e inserite dentro una mappa.


package example.hashmap;

import java.util.HashMap;

public class ProvaMap {

public static void main(String[] args) {

// //ESEMPIO COLLISIONE
Persona p1 = new Persona("mario",1);
Persona p2 = new Persona("gino",2);
Persona p3 = new Persona("flavio",1);// viene messo lo stesso id di p1, l hashcode per
// come definito ritorna l id.

HashMap<Persona, String> mappa = new HashMap<Persona, String>();

mappa.put(p1, "ONE");
mappa.put(p2, "TWO");
mappa.put(p3, "THREE");

 

Persona p1Bis = new Persona("mario",1);

String value = mappa.get(p1Bis);
System.out.println(" value: "+ value);

//nell output si vede che chiama l hashcode per "mario" che da 1,
//// ma nella posizione 1 è memorizzato anche "flavio" quindi
//// chiama anche equals per capire quale chiave è corretta

}

}

L’output sarà:

HashMap esempio collisione

Quando inserisco la p3 nella mappa, nell’output si nota  la chiamata al metodo equals per capire se la chiave già presente nella locazione con indirizzo 1 (ossia p1, “1.mario”) è uguale o no alla p3 (“1.flavio”).  Equals dice che sono diversi quindi avremo che nella locazione 1 ci sono due coppie chiave-valore (p1-ONE e p3-THREE)

Java e Excel – Lettura File

Per poter lavorare con un foglio excel con il progetto Apache POI è perfetto. Completo e semplice da capire.
Per poterlo utilizzare è sufficiente aggiungere le seguenti dependency nel pom.xml:


<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.9</version>
</dependency>

<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.9</version>
</dependency>


La lettura di un file Excel è abbastanza semplice e si compone dei seguenti passaggi:

  1. Creare una istanza di workboot dal foglio Excel
  2. Prendere lo sheet desiderato
  3. Incrementare il numero di riga
  4. iterare tutte le celle di una riga
  5. ripetere il punto 3 e 4 fino a quando tutti i dati vengono letti

Traducendo i passaggi in codice si ha:


package com.proxima.util;

import java.io.File;
import java.io.FileInputStream;
import java.util.Iterator;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
public class ReadExcel {

public static void main(String[] args)
{
try
{
FileInputStream file = new FileInputStream(new File("esempio.xlsx"));

//Create Workbook instance holding reference to .xlsx file
XSSFWorkbook workbook = new XSSFWorkbook(file);

//Get first/desired sheet from the workbook
XSSFSheet sheet = workbook.getSheetAt(0);

//Iterate through each rows one by one
Iterator<Row> rowIterator = sheet.iterator();
while (rowIterator.hasNext())
{
Row row = rowIterator.next();
//For each row, iterate through all the columns
Iterator<Cell> cellIterator = row.cellIterator();

while (cellIterator.hasNext())
{
Cell cell = cellIterator.next();
//Check the cell type and format accordingly
switch (cell.getCellType())
{
case Cell.CELL_TYPE_NUMERIC:
System.out.print(cell.getNumericCellValue() + "t");
break;
case Cell.CELL_TYPE_STRING:
System.out.print(cell.getStringCellValue() + "t");
break;
}
}
System.out.println("");
}
file.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}

}

Java 8: Espressioni Lambda in 5 minuti

Java 8 Lambda: cosa sono

Le espressioni Lambda costituiscono la principale novità per il linguaggio di programmazione Java 8. Esse sono collegate al concetto di funzione anonima (funzione non classe anonima), ossia una funzione che ha un corpo ma non un nome, definita nel punto in cui viene utilizzata. La loro sintassi è qualcosa di simile:

(arg1, arg2) -> {body}

Java 8 Lambda: Esempi
// espressione che prende in input due interi e restituisce la somma
(int x, int y) -> x + y

// espressione che prende in input una stringa e restituisce la sua lunghezza
s -> s.length()

// espressione senza argomenti che restituisce il valore 50
() -> 50

// espressione che prende in input una stringa e non restituisce nulla
(String s) -> { System.out.println(“Benvenuto “);
System.out.println(s); }

//ERRORE
(int x, 5) -> x + y
In un’espressione lambda o nessuno dei tipi dei parametri è dichiarato oppure lo devono essere tutti. Se c’è solamente un parametro, le parentesi tonde possono essere omesse,
Vengono chiamate interfacce funzionali (functional interface) delle interfacce con un solo metodo astratto. Sono generalmente marcate con l’annotazione @FunctionalInterface, anche se non è obbligatorio. Le lambda sono usate con le funcional interface.

Esempio:
// Anonymous Runnable
Runnable r1 = new Runnable(){

@Override
public void run(){
System.out.println(“Hello world old style!”);
}
};

// Lambda Runnable
Runnable r2 = () -> System.out.println(“Hello world with Lambda!”);

E’ abbastanza evidente come con l’uso delle lambda abbiamo ridotto un pezzo di codice da 5 linee a 1 soltanto.
Esempio:

//Prima:
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println(“Sintassi arcinota!”);
}
});

//Dopo:
button.addActionListener( (e) -> {
System.out.println(“Nuova sintassi!”);
});

Ricapitolando, l’espressione lambda è una sintassi più semplice e leggibile per definire-creare un’istanza di una classe anonima che implementa un’interfaccia con un solo metodo astratto. Esse si concentrano solamente sulla definizione dell’unico metodo astratto dell’interfaccia.

Usando le espressioni lambda si può utilizzare un altro strumento aggiunto con java8, i reference method. E’ una nuova sintassi per poter invocare un metodo o un costruttore già esistente.
Esempio:
class Numbers {
public static boolean isMoreThanFifty(int n1, int n2) {
return (n1 + n2) > 50;
}

}

public static void main(String[] args) {

// Using an anonymous class
BiPredicate<Integer, Integer> a = new BiPredicate<Integer, Integer>() {
public boolean test(Integer i1, Integer i2) {
return Numbers.isMoreThanFifty(i1, i2);
}
};

// Using a lambda expression
BiPredicate<Integer, Integer> b = Numbers::isMoreThanFifty;

// Using a method reference
BiPredicate<Integer, Integer> c = (i1, i2) -> Numbers.isMoreThanFifty(i1, i2);

//i tre oggetti sono equivalenti
System.out.println(a.test(2, 3));
System.out.println(b.test(2, 3));
System.out.println(c.test(2, 3));

}
da notare che il metodo isMoreThanFifty ha bisogno di due parametri in input. Con il method reference non sono stati menzionati. Questo perche quando invochiamo il metodo test sull’istanza a.test(10,15), i parametri in input vengono passati in automatico al metodo Numbers.isMoreThanFifty(10, 15).

In generale la sintassi di un method reference può essere una delle seguenti:

NomeClasse::metodoIstanza // Il primo parametro è l’oggetto su cui è invocato
// il metodo e gli eventuali altri parametri sono
// passati al metodo
NomeClasse::metodoStatico // Tutti i parametri sono passati al metodo
oggetto::metodoIstanza // Tutti i parametri sono passati al metodo
E’ possibile anche invocare il costruttore con la stessa sintassi:
String:new

Esempio:

BiPredicate<String,String> eqstr = (s1,s2) -> s1.equals(s2);

con lambda diventa

BiPredicate<String,String> eqstr = String::equals;

eqstr.test(tmp, tmp2);

ossia il metodo equals sarà chiamato su tmp:

tmp.equals(tmp2);