Metodi Java Utili per l'Esame di Programmazione II, Appunti di Programmazione Java

Scarica Metodi Java Utili per l'Esame di Programmazione II e più Appunti in PDF di Programmazione Java solo su Docsity!

Metodi Java utili per l’esame

Programmazione II

String

• String (String other) // clonatore di stringhe
• char charAt(int index) // "papera".charAt(3) ⇔ ’e’
• int compareTo(String other) // ordine lessicografico, ritorna negativo se this viene prima di other, positivo se accade il viceversa, zero se sono equals
• int compareToIgnoreCase(String other) // come compareTo ma maiusc ⇔ minusc
• String concat(String other) // "buon".concat("giorno") ⇔ "buon"+"giorno"
• boolean endsWith(String end) // "leale".endsWith("ale") ⇔ True
• boolean equals(Object other) // "Luca".equals("luca") ⇔ False
• boolean equalsIgnoreCase(String other) // "Luca".equals("luca") ⇔ True
• static String format(String form, Object ... args) // Formato C oriented String.format("La meta di %de = %.2f", 7, 3.5) ⇔ "La meta di 7e 3.50"
• int indexOf(char c) // "pazzo".indexOf(’z’) ⇔ 2
• int indexOf(String s) // "ricarica".indexOf("ica") ⇔ 1
• boolean isEmpty() // "qualcosa".isEmpty() ⇔ False "".isEmpty() ⇔ True
• int length() // "0123456789ABCDEF".length() ⇔ 16
• boolean startsWith(String start) // "aperitivo".startsWith("ape") ⇔ True
  • String substring(int start) (da start incluso)
  • String substring(int start, int end) (da start incluso ad end escluso) // "paleolitico".substring(2,4) ⇔ "leo"
• String toLowerCase() // "LaTeX".toLowerCase() ⇔ "latex"
• String toUpperCase() // "LaTeX".toUpperCase() ⇔ "LATEX"
• String trim() // " frase a caso ".trim() ⇔ "frase a caso"
• static String valueOf(int i) // String.valueOf(174) ⇔ "174" (esegue una conversione esplicita di tipo; esiste per tutti i tipi primitivi, non solo per int; implicitamente usato per la concatenazione con +)

System

• System.in // Es: Scanner keyboard = new Scanner(System.in)
• System.out // Es: System.out.println("Stampa su terminale")
• System.err // Es: System.out.println("Stampa su standard error")
• static long System.currentTimeMillis() // millisec passati dal 1/1/

Scanner java.util.Scanner

• void close() // chiude l’oggetto Scanner aperto in precedenza
• double nextDouble() // interpretazione double del dato successivo
• long nextLong() // interpretazione long del dato successivo
• float nextFloat() // interpretazione float del dato successivo
• int nextInt() // interpretazione intera del dato successivo
• String nextLine() // interpretazione String del dato successivo
• boolean hasNext() // ritorna True se ci sono ancora byte da leggere
• boolean hasNextLine() // ritorna True se ci sono ancora stringhe da leggere

Random java.util.Random

• boolean nextBoolean() // restituisce al 50% True o al 50% False
• double nextDouble() // restituisce un numero double casuale in [0, 1)
• long nextLong() // restituisce un numero long casuale
• float nextFloat() // restituisce un numero float casuale in [0, 1)
• int nextInt(int max) // restituisce un numero int casuale in [0, max)

Math java.util.Math

• static double E // double e = Math.E ⇔ 2,71828...
• static double PI // double pi = Math.PI ⇔ 3,14159...
• static int abs(int a) // valore assoluto (esiste per ogni tipo numerico)
• static double cos(double a) // restituisce il coseno di "a"
• static double log(double a) // restituisce il logaritmo naturale di "a"
• static double log10(double a) // restituisce il logaritmo in base 10 di "a"
• static int max(int a, int b) // valore max (esiste per ogni tipo numerico)
• static int min(int a, int b) // valore min (esiste per ogni tipo numerico)
• static double pow(double a, double b) // restituisce "a" elevato alla "b"
• static double sin(double a) // restituisce il seno di "a"
• static double sqrt(double a) // restituisce a ⇔ pow(a,1/2) √
• static double tan(double a) // restituisce la tangente di "a"
• static double toDegrees(double rad) // converte "rad" in gradi
• static double toRadians(double deg) // converte "deg" in radianti

Enumerazioni

public enum Semi{ Cuori, Quadri, Fiori, Picche }

• static enum[] values() // Semi[] lista = Semi.values()
• static enum valueOf(String nome) // Semi nome = Semi.valueOf("Quadri")
• int compareTo(enum other) // sempre per ordine lessicografico
• int ordinal() // Semi.Picche.ordinal() ⇔ 3

Person P1 = new Person("Jack", 24 ); Person P2 = new Person("Mary", 18 ); Person P3 = new Person("Jack", 21 ); Person P4 = new Person("Mary", 18 );

System.out.println(P1.compareTo(P2)) // valore negativo System.out.println(P1.compareTo(P3)) // valore positivo System.out.println(P2.compareTo(P4)) // zero

• Ciò è fondamentale nel momento in cui la classe Comparable viene impiegata all’interno di una struttura dati, la quale deve permettere ai propri elementi una relazione di ordinamento (ad esempio un TreeSet che implementa un RB albero per tenere ordinata la struttura).
• I tipi elementari come int, char, float [...] sono già comparabili di default.
• Oggetti come String e le classi wrapped sono già comparabili di default.

Integer (classe wrapped)

• static int MAXVALUE // Integer.MAXVALUE ⇔ 231 − 1
• static int MIN VALUE // Integer.MIN VALUE ⇔ −2^31
• Integer(String val) throws java.lang.NumberFormatException // effettua una conversione da stringa a intero se possibile, altrimenti lancia un’eccezione
• int intValue() // passaggio da classe Integer a tipo elementare "int"
• int compareTo(Integer other) // (ecco perchee una classe comparabile)
• static int parseInt(String s) throws java.lang.NumberFormatException // funziona alla stessa maniera di Integer(String val) ma restituisce direttamente un int
• static String toBinaryString(String s) // conversione da decimale a binario
• static String toHexString(String s) // conversione da decimale a esadecimale

Character (classe wrapped)

• static int MAXVALUE // Character.MAX VALUE ⇔ 0xFFFFF in unicode
• static int MIN VALUE // Character.MIN VALUE ⇔ 0x00000 in unicode
• char charValue() // passaggio da classe Character a tipo elementare "char"
• int compareTo(Character other) // ecco perchee una classe comparabile
• static boolean isDigit(char c) // Character.isDigit(’6’) ⇔ True
• static boolean isLetter(char c) // Character.isLetter(’#’) ⇔ False
• static boolean isLetterOrDigit(char c) // Character.isLetterOrDigit(’g’) ⇔ True
• static boolean isLowerCase(char c) // Character.isLowerCase(’P’) ⇔ False
• static boolean isUpperCase(char c) // Character.isUpperCase(’P’) ⇔ True
• static boolean isWhiteSpace(char c) // Character.isWhiteSpace(’ ’) ⇔ True
• static char toLowerCase(char c) // Character.toLowerCase(’Y’) ⇔ ’y’
• static char toUpperCase(char c) // Character.toUpperCase(’’) ⇔ ’’

Tutte le collezioni standard di Java (come List, Set, Queue) implementano Iterable automaticamente.

• Se una classe implementa il metodo iterable() per fornire un criterio di ”iterabilità” ad una collezione di oggetti, allora è detta ”iterabile” e può implementare la classe Iterable, ad esempio: public class Person implements Iterable
• Il metodo iterable() si occupa di ritornare un oggetto che permette l’iterazione sequenziale della classe che lo chiama, e questo è fondamentale nel momento in cui si vuole creare una struttura dati.
• In Java tutte le strutture dati di default implementano Iterable infatti esse sono sempre scansionabili tramite un costrutto for-each, ecco un esempio: List animali = new ArrayList<>(); // L’ArrayList `e iterabile int index = 1 ; animali.add("cane"); animali.add("gatto"); animali.add("pappagallo"); animali.add("coniglio"); for(String animale: animali) { System.out.println("Animale numero " + i + ": " + animale); i++; }

Collection java.util.Collection

• boolean add(E elem) // Aggiunge un elemento e restituisce true se l'operazione ha successo.
• boolean addAll(Collection other) // Aggiunge tutti gli elementi di un'altra Collection, True se almeno un elemento è aggiunto
• boolean contains(Object elem) // ritorna True se l’elemento è nella collezione
• boolean containsAll(Collection other) // True se tutti gli elementi presenti
• boolean isEmpty() // Ritorna True se la collezione è vuota
• boolean remove(Object elem) // True se l’elemento viene rimosso correttamente
• boolean removeAll(Collection other) // Ritorna True se almeno uno è rimosso da other
• boolean retainAll(Collection other) // rimuove dalla collezione tutti gli elementi non presenti in other, e ritorna True se almeno un elemento è stato rimosso
• int size() // fornisce il numero di elementi presenti nella collezione Nota : Collection non può essere usata direttamente, ma è l’interfaccia madre di tutte le strutture dati. Collections.sort(cars); // Sort cars Per invertire l’ordine mettere in fondo alla lista “Collections.sort(cars, Collections.reverseOrder());”

List java.util.List

Liste ordinate di elementi

List è un tipo di Collection che permette di gestire elementi in ordine e accedervi tramite indice. Nota : List può contenere duplicati e mantiene l’ordine di inserimento.

• Eredita tutti i metodi di Collection, tuttavia è opportuno ricordare che il metodo add() aggiunge l’elemento in fondo alla lista, mentre remove() rimuove l’elemento in cima alla lista.
• static List of (E... elems) // creazione di una lista con elementi
• void add(int index, E elem) // aggiunta in una posizione precisa nella lista
• E get(int index) // ritorna l’elemento in posizione "index" nella lista
• int indexOf(Object elem) // ritorna l’indice dell’elemento nella lista
• E remove(int index) // come "get()" ma l’elemento viene anche rimosso
• E set(int index, E elem) // come "get()" ma l’elemento viene anche sostituito

ArrayList java.util.ArrayList

ArrayList è una lista basata su array che cresce dinamicamente quando necessario.

• Eredita tutti i metodi di List.
• E[] toArray() // trasforma la struttura dati in un array elementare
• int lastIndexOf(Object elem) // ritorna l’indice dell’ultima occorrenza dell’elemento "elem" nella lista; in caso non ci siano occorrenze ritorna - 1
• List sublist(int fromIndex, int toIndex) // estrae un oggetto "List" contenente gli elementi dell’ArrayList indicizzati da "fromIndex" a "toIndex"

LinkedList java.util.LinkedList

LinkedList è una lista in cui ogni elemento è collegato al successivo e al precedente.

• Eredita tutti i metodi di Queue e di List.
• void addFirst(E elem) // inserisce l’elemento ad inizio lista
• void addLast(E elem) // inserisce l’elemento a fine lista

Set java.util.Set

Set - Insieme di elementi unici

• Eredita tutti i metodi di Collection.
• static Set of (E... elems) // creazione di un Set con elementi

HashSet java.util.HashSet

HashSet è un tipo di Set che non permette duplicati e usa una tabella hash per memorizzare gli elementi.

• Eredita tutti i metodi di Set implementandoli in una tabella hash.
• L’oggetto su cui si costruisce un HashSet deve implementare il metodo hashCode(), il quale deve ritornare un intero elaborato in modo non banale e tale per cui se due oggetti sono equals() allora condividono tale valore.

SortedSet java.util.SortedSet

SortedSet è un Set che mantiene gli elementi ordinati in modo naturale (cioè, in base a Comparable) o secondo un comparatore specificato.

• Eredita tutti i metodi di Set, però tenendo ordinati gli elementi (gli oggetti E devono implementare Comparable, altrimenti è possibile passare il comparatore di un’altra classe da utilizzare).
• E first() throws java.util.NoSuchElementException // ritorna il primo
• E last() throws java.util.NoSuchElementException // ritorna l’ultimo Nota: SortedSet è un’interfaccia, quindi per usarla bisogna scegliere un'implementazione come TreeSet.

TreeSet java.util.TreeSet

TreeSet è una classe che implementa SortedSet usando un albero rosso-nero (Red-Black Tree).

• Eredita tutti i metodi di SortedSet implementandoli in un RB albero.

Map java.util.Map<K,V >

Una Map<K, V> è una struttura dati che associa una chiave (K) a un valore (V). Pensa a un dizionario : ogni parola (chiave) ha un significato (valore). Le chiavi sono uniche (non possono essere duplicate). I valori possono essere duplicati (ma ogni chiave può avere solo un valore associato).

• La struttura dati Map si occupa di associare gli elementi di un Set di chiavi a degli elementi di una Collection di valori, e non implementa né Iterable né Comparable.
• V compute(K key, Function<? super K,? extends V>) // funziona come "put()" tuttavia permette di elaborare il valore da inserire nella mappa con la Function
• V computeIfAbsent(K key, Function<? super K,? extends V>) // funziona come "putIfAbsent()" ma anche in questo caso `e possibile elaborare il valore
• boolean containsKey(Object key) // ritorna True se la mappa ha quella chiave
• boolean containsValue(Object value) // ritorna True se la mappa ha quel valore
• V get(Object key) // restituisce il valore associato a quella chiave
• V GetOrDefault(Object key, V default) // come "get()" ma in caso non esista nessun valore associato alla chiave restituisce un oggetto "default" di tipo "V"
• boolean isEmpty() // ritorna True se la mappa `e vuota
• Set keySet() // restituisce tutti gli elementi del Set delle chiavi
• V put(K key, V value) // inserisce un elemento nell’insieme delle chiavi, e il valore associato nell’insieme dei valori; ritorna il vecchio valore eventualmente
• V putIfAbsent(K key, V value) // come "put()" ma va solo se non c’`e la key
• V remove(Object key) // rimuove la chiave e il valore associato, restituendolo
• int size() // fornisce il numero di associazioni key-value nella mappa
• Collection values() // ritorna tutti gli elementi dell’insieme dei valori

TreeMap java.util.TreeMap<K,V >

• Eredita tutti i metodi di Map, con l’unica differenza che l’insieme delle chiavi non è più un Set ma un TreeSet, dunque è garantito l’ordinamento aggiornato ad ogni inserimento o rimozione.

Classe Object

• Tutti gli oggetti estendono qualche oggetto
• Se non si estende un'altra classe, si estende (implicitamente) Object
• Object è l'unico oggetto che non estende nessun altro oggetto.
• Tutti gli oggetti ereditano (direttamente o indirettamente) da Object, per cui i suoi metodi sono presenti in tutti gli oggetti Java.
• Ogni oggetto può essere convertito ad Object, e infatti quando occorre riferirsi a qualsiasi oggetto si utilizza un riferimento ad Object. Input/Output Consideriamo i concetti principali della package per la gestione di Input/Output
• Il package per l'I/O è java.io, e le classi si usano con import java.io.*
• Il concetto principare è lo Stream, un oggetto in cui si scrive (OutputStream) e da cui si legge (InputStream)
• Ci sono due gruppi di classi molto simili, un gruppo per l'Input ed l'altro per Output
• Ci sono casi particolari come RandomAccessFile
• Gestione di nomi di file indipendente dalla piattaforma
• Tutte le eccezioni di I/O sono derivate da IOException

DataStream

• Sono stream filtro, nel senso che operano su uno stream esistente e vi aggiungono i metodi per potenziare le capacità degli stream base
• DataInputStream e DataOutputStream consentono di leggere e scrivere i vari tipi di Java (non solo byte): o boolean, char, byte, short, int, long, float, double con metodi dal nome ovvio: readBoolean, writeBoolean...
• Notare la readLine() per leggere una linea di testo, che riconosce gli End−Of−Line (\n, \r, \n, \r, o \r\n) ritorna null quando è fine−file
• Non esiste la corrispondente writeLine()
• Invece esiste writeBytes (String s) (che taglia il byte alto) Classi varie
• RandomAccessFile, consente la lettura e la scrittura in qualunque posizione di un file
• BufferedInputStream, BufferedOutputStream, stream bufferizzati
• PushbackInputStream, stream filtro con "unread (int)" per mandare indietro un byte
• PrintStream print e println per: String, char, int., long... con autoflush quando incontro un '\n' (disabilitabile) System.out è un PrintStream
• SequenceInputStream concatena più Stream: FileInputStream files = { new FileInputStream ("a"), new FileInputStream ("b") }; InputStream in = SequenceInputStream (files);
• PipedStream, collega uno stream di input in uno stream di output PipedOutputStream out = new PipedOutputStream() ; Ci vogliono due Thread per usarlo, uno che scrive e uno che legge.
• ByteArrayInputStream e ByteArrayOutputStream, sono Stream "costanti" da usare per leggere dati fissi o per scrivere in memoria dati o ByteArrayInputStream(byte[] data), Costruisce un input stream costante da un array di byte o ByteArrayOutputStream (), Costruisce un output stream che raccoglie byte ▪ size(), Numero di byte scritti ▪ byte[] toByteArray(), Restituisce i byte scritti come un array ▪ String toString ([int hibyte]), Restituisce i byte scritti come una stringa, usa hibyte come byte alto (0 default)

1. Lettura e Scrittura di File in Java

In Java, la gestione dei file si basa sul pacchetto java.io e sul più recente java.nio.file. I metodi più comuni per lavorare con i file sono:

1. Lettura e scrittura di file di testo
2. Lettura e scrittura di file binari
3. Gestione del buffering per migliorare le prestazioni
4. Utilizzo di Scanner per una lettura più strutturata
5. Uso di Files (da java.nio.file) per operazioni più moderne
6. Lettura e scrittura di oggetti (Serializzazione)

2. Lettura di File di Testo (Character Streams)

I Character Streams lavorano con caratteri Unicode e sono ideali per la lettura di file testuali. A. Classe astratta java.io.Reader Tutte le classi di lettura derivano da java.io.Reader, che fornisce metodi base:

• int read() → legge un carattere alla volta e restituisce il valore Unicode.
• int read(char[] buffer) → legge più caratteri alla volta in un array.
• void close() → chiude lo stream. B. FileReader (Lettura diretta da file) Eredita da Reader ed è utilizzato per leggere file di testo. Svantaggio : Legge carattere per carattere, quindi è inefficiente. C. BufferedReader (Lettura con buffer) Migliora le prestazioni leggendo blocchi di testo invece di singoli caratteri.