Java Passaggio Parametri

– Indice Tutorial –

Come sappiamo, i metodi accettano delle variabili in input. Questa operazione viene chiamata “passaggio di parametri”.

Una variabile, chiamiamola X, di tipo primitivo, viene passata ad un metodo per valore (passaggio parametri per valore): il metodo crea una copia della variabile X, chiamiamola X1, in input, e userà questa al suo interno. Perciò, tutte le modifiche fatte su X1, non influenzeranno in nessun modo X, che manterrà il suo valore originale.

Esempio:

public class provatre {
	public int helloR(int x) {
		x++;
		return x;
	}
	
	public static void main(String[] args) {
		provatre p = new provatre();
		int count = 15;
		p.helloR(count);
		System.out.println(count);
	}
}

I Metodi In Java

– Indice Tutorial –

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.

La Ricorsione in Java

– Indice Tutorial –

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:

sospende l’esecuzione del metodo invocante
esegue il metodo invocato fino alla sua conclusione
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.

Modificatori Di Visibilità In Java

– Indice Tutorial –

Modificatore	Effetto
Public	visibile da qualsiasi parte del programma
Private	visibile solo all’interno della stessa classe
Protected	visibile solo dalle classi dello stesso package e da tutte le sottoclassi
Default	visibile 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

– Indice Tutorial –

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.

Video Lezione Sulle Classi Java

Cenni Sulla Programmazione Orientata agli Oggetti (OOP)

– Indice Tutorial –

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.

Array in Java

– Indice Tutorial –

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.

Java Syncronized: Come si usa esempio

– Indice Tutorial –

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

Leggi tutto “Java Syncronized: Come si usa esempio”

Java HashMap – Esempio Collisione

– Indice Tutorial –

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.

[java]

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;
}
}

[/java]

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.

[java]

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

}

[/java]

L’output sarà:

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:

Creare una istanza di workboot dal foglio Excel
Prendere lo sheet desiderato
Incrementare il numero di riga
iterare tutte le celle di una riga
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();
		}
	}

}