Comparable e Comparator

Comparable – è un’interfaccia che offre il metodo a.compareTo(b) per confrontare l’oggetto corrente con un altro.

Comparator è un’interfaccia che offre il metodo compare(a,b) per confrontare due oggetti passati in input.

Arrays.sort Serve ad ordinare un array di elementi comparabili.

Strutture dati utilizzate per organizzare i dati in maniera efficente (in tempo e spazio).

Java Collections è una gerarchia di classi Java che contiene le strutture dati più comuni. Come List, Set, Map.

Collections List, Set, Map

COLLECTION

La collection è un’interfaccia principale.
è la più astratta in assoluta.
è una collezione di oggetti omogenei che non ha vincoli sul numero massimo di elementi, può essere ordinata o meno e accetta elementi duplicati.
Sulla base di questa interfaccia sono state modellate altre interfacce List, Set, Map.

LIST

è una lista di elementi che non garantisce l’ordinamento degli elementi.
Per utilizzare una lista abbiamo a disposizione le classi concrete ArrayList o LinkedList.

Consultare le API per avere conoscenza dei vari metodi a disposizione. Esiste il metodo .get(indicePosizione) per ottenere elemento avendo l’indice.
Ed il metodo .contains(elemento) per capire se contiene quell’elemento.

Per utilizzare le liste bisogna importare le classi.

import java.util.List;
import java.util.ArrayList;

//esempio lista di interi
List<Integer> lista = new ArrayList<>();
//esempio lista di qualsiasi classe che creiamo come Libro o Pizza
List<Libro> libreria = new ArrayList<>();


//Si legge cosi: PER ogni "Integer" che chiamiamo "e" della lista : "lista"
for (Integer e:lista)
System.out.println(e);

//per stampare possiamo direttamente passare il nome della lista a un println
System.out.println(lista);
//NB ha funzionato per lista perché è un ArrayList di Integer, che fa già ovverride del metodo toString
se vogliamo che funzioni per le classi che creiamo noi dobbiamo prima provvedere a fare override di toString. 

System.out.println(libreria);


lista.add(14);
lista.add(10);
lista.add(14);
		
System.out.println(lista.get(0)); //stampa il 14

System.out.println(lista.size()); // risultato 3 perché List accetta i duplicati 

//rimuove elemento dato un indice		
lista.remove(1); //rimuove il n°10 

//altro metodo add che accetta anche indice. 
//aggiunge in indice 1 il numero 85
lista.add(1,85); 

SET

l’interfaccia Set modella un insieme. La utilizziamo quando abbiamo bisogno di gestire una lista che non può avere duplicati quindi è molto importante se creiamo una lista set di una classe che abbiamo creato noi, fare l’override dei metodi equals e hashCode. Per dire a Java cosa abbiamo deciso di tenere da conto per dire che due oggetti sono uguali.

Esistono due implementazioni per Set:

  • HashSet – gli elementi non sono ordinati
  • TreeSet – gli elementi sono ordinati
import java.util.Set;
import java.util.HashSet;

//inizializzare un set con treeset o hashset
Set pizzeria = new TreeSet<>();
Set pizzeria = new HashSet<>();

Set set = new HashSet<>();
set.add(7);
set.add(6);
set.add(7);

System.out.println(set.size());//risultato 2 perchè non permette di aggiungere proprio due numeri uguali essendo un insieme.

NB se mi serve che gli elementi siano anche ordinati devo usare un TreeSet ma devo implementare Comparable o fornire un comparator alla classe degli elementi che inserisco all’interno del Set in modo che il metodo add possa inserire l’elemento nella posizione corretta.

MAP

Rappresenta delle associazioni tra chiavi e valori. Non ammette chiavi duplicate.

Esistono due implementazioni per Map:

  • HashMap – gli elementi non sono ordinati
  • TreeMap – gli elementi sono ordinati per Chiave

A cosa serve? Esempio: chiave = nome utente e valore=password

Map menu = new HashMap<>();
		
		menu.put("Margherita", 5);
		menu.put("Diavola", 7);
		menu.put("Margherita", 4);
		
		System.out.println(menu.size());

//METODO FOR PER IL MAP
for(Map.Entry entry:menu.entrySet()) {
   System.out.println(entry.getKey());	//margherita, diavola
   System.out.println(entry.getValue());//7,4
}

menu.put("Prosciutto", 5);
menu.remove("Margherita");

System.out.println(menu);

Classi Astratte e Interfacce

Le classi astratte sono delle classi che non ha senso istanziare.
Sono concetti astratti. Creo una classe astratta con un metodo astratto che obbliga le sottoclassi a fare un Override di quel metodo.
Infatti quando una classe estenderà la nostra superclasse astratta, sarà obbligata a implementare tutti i metodi astratti di quella classe astratta.

Una superclasse può essere astratta se non ha senso mai istanziarla.

Dubbi? Quando può aver senso istanziare la classe?
Se ha senso allora Superclasse normale.
Se invece No. scegli se usare le classi astratte o le interfacce.


public abstract class SocialMediaAccount{

}

NB Una volta definito che una classe è astratta (inserendo la parola abstract) se noi proviamo a istanziare un oggetto da quella classe astratta, possiamo solo dichiararlo, ma Java non ci permette di crearlo in perché le classi astratte non hanno proprio il costruttore, non ne viene dato uno vuoto di default come accade per le classi normali.

Le interfacce

Le interfacce definiscono i metodi che le classi devono implementare obbligatoriamente. Le interfacce sono molto generiche e possono essere rea tate classi diverse.

Una classe può implementare più interfacce. Quando una classe implementa un’interfaccia, vuol dire che è costretta ad implementare i metodi imposti dall’interfacia. l’Interfaccia è un concetto astratto.

Una classe può implementare diverse Interfacce, ma può estendere solo una Superclasse.

se definisco una Superclasse Veicolo con delle caratteristiche la sottoclasse automobile erediterà tutte le caratteristiche. A volte però è utile che la mia sottoclasse automobile erediti delle caratteristiche aggiuntive che non sono della superclasse veicolo, per questo si utilizzano quante interfacce possibili.

l’interfaccia impone un metodo ma non dice come deve essere quel metodo. Indica solo nome e firma.
Proprio perchè deve essere poter utilizzata per concetti generici, astratti.
Infatti non ci sono le graffe dopo questo metodo ma solo chiusura con ;.
Si occuperà la classe che implementa a definire il metodo.


public interface Session {

boolean login (String username, String password);

}

Dopo JAVA9 è stato concessaa la possibilità di definire metodi statici e di default, dentro le interfacce, che si ereditano normalmente come in una classe tradizionale.
Ma il concetto generale è che all’interno dell’interfaccia devi stabilire un elenco di caratteristiche e firme che vuoi che le classi che la implementano devono mantenere.

Modificatori di accesso: private, protected e public, final static ed eccezioni

private = visibile solo alla classe corrente
protected = visibile alle sottoclassi
public = visibile da tutti

lo scopo è che bisogna far si che le classi si parlino tra di loro solo attraverso i metodi e non gli attributi che è meglio siano sempre private.

se non usiamo niente dichiarando solo attributo senza modificatore di accesso allora di default sarà visibile a tutte le classi dello stesso package.
Il package raggruppa le classi aiuta la modularità tramite le regole di visibilità e disambigua le classi con lo stesso nome perchè appunto fanno parte di package differenti.

per il nome dei package di regola si usa il nome del dominio al contrario.
esempio com.esempio.test

final 

indica un valore che non può essere cambiato. È già la sua versione finale.

static

è presente in tutti gli oggetti.

se indichiamo un attributo sia static che final allora diciamo che è una costante.

eccezioni