Dal linguaggio C al linguaggio Java

Boxing e unboxing

Integer intO;
intO = 13;               // conversione boxing: è equivalente a
intO = new Integer(13);  // questo

int k;
k = intO;                // conversione unboxing: è equivalente a
k = intO.intValue();     // questo

k = intO*intO;              // unboxing
intO = k*intO*(2 + intO);   // unboxing e boxing
Character charO = 'A';      // boxing
char c = charO;             // unboxing

public static int sum(Integer[] a) {
    int s = 0;
    for (int i = 0 ; i < a.length ; i++)
        s += a[i];        // unboxing
    return s;
}

public static Integer sumInteger(Integer[] a) {
    return sum(a);        // boxing
}

Integer[] integerA = new Integer[] {2, 10003, 13};   // boxing
Integer intO = 13;
int[] intA = new int[] { intO, 2*intO };             // unboxing

intA = integerA;   // ERRORE in compilazione: tipi incompatibili (Integer[] e int[])
integerA = intA;   // ERRORE in compilazione: tipi incompatibili (Integer[] e int[])

int k = sum(integerA);
k = sumInteger(integerA);
k = sum(intA);    // ERRORE in compilazione: tipi incompatibili (Integer[] e int[])

if (sum(integerA) == sum(integerA))                 // VERO
    ...
if (sumInteger(integerA) == sumInteger(integerA))   // FALSO
    ...

Integer intO = 12345;
Integer intO2 = 12345;
if (12345 == intO)                     // VERO (unboxing)
    ...
if (intO2 == intO)                     // FALSO (oggetti differenti)
    ...
if ((int)intO2 == intO)                // VERO (unboxing)
    ...
if (intO2 <= intO)                     // VERO (unboxing)
    ...

Number num = 13;          // boxing in Integer
num = intO;
num = 3.14;               // boxing in Double
int k = num;              // ERRORE: tipi incompatibili (int e Number)
double d = num;           // ERRORE: tipi incompatibili (double e Number)
Double dO = num;          // ERRORE: tipi incompatibili (Double e Number)
num = new Number();       // ERRORE: Number è una classe astratta
Number[] numA;
numA = integerA;
numA = intA;              // ERRORE: tipi incompatibili (Number[] e int[])

Object obj = 13;          // boxing in Integer
obj = 'a';                // boxing in Character
obj = 3.14;               // boxing in Double
obj = true;               // boxing in Boolean
boolean b;
b = obj;                  // ERRORE: tipi incompatibili (boolean e Object)
b = (boolean)obj;         // ERRORE: tipi non convertibili (boolean e Object)
b = (Boolean)obj;         // OK

Metodi generici

public class Test {
        // metodo generico: T è la variabile di tipo
    public static <T> int find(T[] a, T x) {
        for (int i = 0 ; i < a.length ; i++)
            if (a[i].equals(x)) return i;
        return -1;
    }

    public static int find2(Object[] a, Object x) {
        for (int i = 0 ; i < a.length ; i++)
            if (a[i].equals(x)) return i;
        return -1;
    }

    public static void main(String[] args) {
        String[] sA = new String[] {"A", "B", "C"};
        Integer[] intA = new Integer[] {12, 23, 1, 234};
        int k;
        k = find(sA, "C");             // T è sostituita con String
        k = find(intA, 2);             // T è sostituita con Integer
        k = find(intA, "A");
            // le stesse invocazioni sono possibili anche con il metodo find2()
        k = find2(sA, "C");
        k = find2(intA, 2);
        k = find2(intA, "A");
    }
}

        k = Test.<String>find(intA, "A");    // ERRORE in compilazione
        k = Test.<Integer>find(intA, "C");   // ERRORE in compilazione
        k = Test.<Integer>find(intA, 2);     // OK

public class Test {
   public static <T> void fill(T[] a, T x) {
        for (int i = 0 ; i < a.length ; i++)
            a[i] = x;
    }

    public static void fill2(Object[] a, Object x) {
        for (int i = 0 ; i < a.length ; i++)
            a[i] = x;
    }

    public static void main(String[] args) {
        String[] sA = ...
        Integer[] intA = ...
        fill(intA, 13);
        fill2(intA, 13);
        fill(intA, "A");                 // ERRORE in esecuzione: ArrayStoreException
        fill2(intA, "A");                // ERRORE in esecuzione: ArrayStoreException
        Test.<Integer>fill(intA, "A");   // ERRORE in compilazione
        fill(sA, "A");
        fill(sA, 12);                    // ERRORE in esecuzione: ArrayStoreException
        Test.<String>fill(sA, 12);       // ERRORE in compilazione
        Test.<String>fill(sA, "A");
    }
}

public class Test {
    public static <T> T getMiddle(T[] a) {
        return a[a.length/2];
    }

    public static Object getMiddle2(Object[] a) {
        return a[a.length/2];
    }

    public static <T> T longestString(T[] a) {
        T val = null;
        int max = 0;
        for (int i = 0 ; i < a.length ; i++)
            if (a.toString().length() >= max) val = a[i];
        return val;
    }

    public static void main(String[] args) {
        String[] sA = ...
        Integer[] intA = ...
        int k = getMiddle(intA);
        k = getMiddle(sA);              // ERRORE in compilazione
        String s = getMiddle(sA);
        s = getMiddle2(sA);             // ERRORE in compilazione: richiesto cast (String)
        s = (String)getMiddle2(sA);     // OK
        k = (Integer)getMiddle2(sA);    // ERRORE in esecuzione: ClassCastException

        k = longestString(intA);
        s = longestString(sA);
    }
}

public class Test {
    public static <T> T[] shuffledShallowCopy(T[] a) {
        T[] copy = a.clone();
        int n = copy.length;
        int m = 20*n;
        for (int i = 0 ; i < m ; i++) {
            int k = (int)Math.random()*n;
            int h = (int)Math.random()*n;
            T x = copy[k];
            copy[k] = copy[h];
            copy[h] = x;
        }
        return copy;
    }

    public static void main(String[] args) {
        String[] sA = ...
        Integer[] intA = ...
        String[] shuffledSA = shuffledShallowCopy(sA);
        Integer[] shuffledIntA = shuffledShallowCopy(intA);
        shuffledSA = shuffledShallowCopy(intA);          // ERRORE in compilazione
        Object[] objA;
        objA = shuffledShallowCopy(intA);                // OK
        intA = shuffledShallowCopy(objA);                // ERRORE in compilazione
    }
}

Esercizi

public class Test {
    public static <T> T first(T[] A, T[] B) {
        int i = 0;
        while (i < A.length && i < B.length && !A[i].equals(B[i]))
            i++;
        return (i < A.length && i < B.length ? A[i] : null);
    }
    public static void main(String[] args) {
        long[] longA = {2, new Long(5)};
        int[] intA = {1, 2, 3};
        int val = first(longA, longA);
        val = first(longA, intA);
        Integer[] intA2 = {2, 3, 4};
        Long[] longA2 = {1L, 2L, 3L};
        val = first(intA2, longA2);
        Long vL = first(intA2, longA2);
        Number num = first(intA2, longA2);
    }
}

public class Test {
    public static <E> E sub(E[] a, E v) {
        int i = 0;
        while (i < a.length && !v.toString().equals(a[i].toString()))
            i++;
        if (i < a.length) {
            E c = a[i];
            a[i] = v;
            return c;
        } else return null;
    }
    public static void main(String[] args) {
        String[] sA = {"A", "B", "C"};
        String s = sub(sA, "D");
        Integer[] intA = {1, 2, 3};
        int k = sub(intA, 13);
        k = sub(intA, "2"); 
        Object obj = sub(intA, "3");
        obj = Test.<Integer>sub(intA, '4');
        Object[] objA = {2, 3, 4};
        Integer v = sub(objA, 2);
    }
}

MATRICE di Double                      MATRICE di String
0.123    23.5    12.01                 Roma    Milano           Genova
1        0.4     1.234                 Napoli  Reggio Calabria  Teramo
1234567  67.897  12                    Terni   Palermo          Perugia

Tipi generici

public class Pair<T> {
    private T first, second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }
    
    public T getFirst() { return first; }
    public T getSecond() { return second; }

    public void setFirst(T x) { first = x; }
    public void setSecond(T x) { second = x; }
}

Pair<String> strPair = new Pair<String>("primo", "secondo");
strPair.setFirst("I");
strPair.setSecond(2);       // ERRORE in compilazione: Integer non è un sottotipo di String

Pair<Integer> intP = new Pair<Integer>(13, 17);    // boxing
intP.setFirst(11);          // boxing
intP.setSecond("13");       // ERRORE in compilazione: String non è un sottotipo di Integer
int k = intP.getFirst();    // unboxing
String s = intP.getFirst(); // ERRORE in compilazione: Integer non è un sottotipo di String

Pair<Pair<String>> strPairPair = new Pair<Pair<String>>(strPair, strPair);

public class StrPair {
    private String first, second;

    public Pair(String first, String second) {
        this.first = first;
        this.second = second;
    }
    
    public String getFirst() { return first; }
    public String getSecond() { return second; }

    public void setFirst(String x) { first = x; }
    public void setSecond(String x) { second = x; }
}

// in un file Point.java
public class Point {
    private int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

// in un file LPoint.java
public class LPoint extends Point {
    private String label;

    public LPoint(int x, int y, String label) {
        super(x, y);
        this.label = label;
    }

    public String getLabel() { return label; }
}

Pair<Point> pntPair = new Pair<Point>(new Point(0, 0), new Point(1, 1));
pntPair.setFirst(new LPoint(0, 0, "A"));   // OK: LPoint è un sottotipo di Point

LPoint lp1 = new LPoint(0, 0, "A");
LPoint lp2 = new LPoint(1, 1, "B");
Pair<LPoint> lpPair = new Pair<LPoint>(lp1, lp2);
lpPair.setFirst(new Point(0, 0));   // ERRORE in compilazione: Point non è un
                                    // sottotipo di LPoint
pntPair = lpPair;                               // 1. ERRORE in compilazione
pntPair.setFirst(new Point(0, 0));              // 2. se (1) non fosse un errore allora...
String label = lpPair.getFirst().getLabel();    // 3. qui si avrebbe un errore in esecuzione
        
Pair<Object> objPair = new Pair<Object>("B", new Point(0, 0));
objPair.setFirst(lp1);
objPair = pntPair;   // ERRORE in compilazione: Pair<Point> non è un sottotipo di Pair<Object>

LPoint[] lpA = new LPoint[3];
Point[] pA = lpA;              // lecito perché LPoint[] è un sottotipo di Point[]
pA[0] = new Point(0, 0);       // ERRORE in esecuzione (non rilevabile dal compilatore) 

Pair<String>[] strPairA;           // OK
strPairA = new Pair<String>[3];    // ERRORE in compilazione

public class DPair<F, S> {
    private F first;
    private S second;

    public DPair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    public F getFirst() { return first; }
    public S getSecond() { return second; }

    public void setFirst(F x) { first = x; }
    public void setSecond(S x) { second = x; }
}

public class Pair<T> extends DPair<T, T> {
    public Pair(T first, T second) {
        super(first, second);
    }
}

public interface Comparable<T> {
    int compareTo(T obj);
}

public class Point implements Comparable<Point> {
    private int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }

    public int compareTo(Point p) {
        if (p == null) throw new NullPointerException();
        int px = p.getX(), py = p.getY();
        if (px == x && py == y) return 0;                // this è uguale a p
        else if (px < x || (px == x && py < y))
            return 1;                                    // this è maggiore di p
        else return -1;                                  // this è minore di p
    }
}

public static <T> T min(T[] a) {
    T min = a[0];
    for (int i = 1 ; i < a.length ; i++)
        if (a[i].compareTo(min) < 0)    // ERRORE in compilazione: non trova compareTo()
            min = a[i];
    return min;
}

public static <T extends Comparable<T>> T min(T[] a) {
    T min = a[0];
    for (int i = 1 ; i < a.length ; i++)
        if (a[i].compareTo(min) < 0)
            min = a[i];
    return min;
}

Point[] pA = new Point[] {new Point(2, 3), new Point(1, 5), new Point(1, 4)};
Point minP = min(pA);
System.out.println("Min Point = ("+minP.getX()+", "+minP.getY()+")");
Integer[] pI = new Integer[] {3, 4, 1, 0, -3, 6};
int m = min(pI);
System.out.println("Min Integer = "+m);
LPoint[] lpA = new LPoint[] {new LPoint(0, 0, "a"), new LPoint(0, -1, "b")};
LPoint minLP = min(lpA);       // ERRORE in compilazione

Esercizi

class LDPair<F, S> extends DPair<F, S> {
    private String label;
    public LDPair(F f, S s, String l) {
        super(f, s);
        label = l;
    }
    public String getLabel() { return label; }
}

public class Test {
    public static void main(String[] args) {
        DPair<Integer, Number> dp = new LDPair<Integer, Number>(12, 2.6, "A");
        String s = dp.getLabel();
        DPair<Object, Object> objp = new DPair<String, String>("A", "B");
        DPair<Long, Long>[] pA = new DPair<Long, Long>[5];
        DPair<DPair<Long, Long>, int[]> t =
                new DPair<DPair<Long, Long>, int[]>(new DPair<Long, Long>(1L, 1L), new int[5]);
    }
}

class CN implements Comparable<Integer> {
    private String val;
    public CN(String v) { val = v; }
    
    public int compareTo(Integer o) {
        if (o == null) throw new NullPointerException();
        int len = val.length();
        return (len < o ? -1 : (len > o ? 1 : 0));
    }
}

public class Test {
    public static <T extends Comparable<Integer>> boolean below(T[] a, int b) {
        for (int i = 0 ; i < a.length ; i++)
            if (a[i].compareTo(b) > 0) return false;
        return true;
    }
    public static void main(String[] args) {
        CN[] a = new CN[] {new CN("A"), new CN("B")};
        boolean r = below(a, 13);
        Integer[] intA = new Integer[] {1, 2, 3};
        r = below(intA, 10);
        int[] iA = {1, 2, 3};
        r = below(iA, 5);
    }
}

    INPUT                                        OUTPUT
    {"B", "AB", "A", "B"}                        ("B", 2)
    {2, 13, 2, 1, 13, 13}                        (13, 3)                  

ARRAY           {"A", "AB", "B", "A", "AB", "AB"}
MULTI-INSIEME   {("A", 2), ("AB", 3), ("B", 1)}

Wildcards

<? extends Type>

rappresenta un qualsiasi tipo che è un sottotipo di Type.

<? super Type>

rappresenta un qualsiasi tipo che è un supertipo di Type.

<?>

rappresenta un qualsiasi tipo che è un sottotipo di Object, quindi un qualsiasi tipo riferimento senza restrizioni. È equivalente a <? extends Object>.

import static java.util.Arrays.*;

public class DynamicArray<T> {
    private T[] array;

    public DynamicArray() {
        array = (T[])new Object[0];      
    }

    public int getSize() { return array.length; }

    public void setSize(int size) {
        if (size < 0) throw new IllegalArgumentException();
        array = copyOf(array, size);
    }

    public T get(int index) {
        if (index < 0 || index >= array.length)
            throw new IllegalArgumentException();
        return array[index];
    }

    public void set(int index, T x) {
        if (index < 0 || index >= array.length)
            throw new IllegalArgumentException();
        array[index] = x;
    }
}

public static <T> void printDynArray(DynamicArray<T> a) {
    int size = a.getSize();
    for (int i = 0 ; i < size ; i++) System.out.println(a.get(i));
}

public static void printDynArray(DynamicArray<?> a) {
    int size = a.getSize();
    for (int i = 0 ; i < size ; i++) System.out.println(a.get(i));
}

    public void append(DynamicArray<T> a) {
        int size = a.getSize();
        int oldSize = array.length;
        setSize(oldSize + size);
        for (int i = 0 ; i < size ; i++) array[oldSize + i] = a.get(i);
    }

DynamicArray<Point> pntDA = new DynamicArray<Point>();
DynamicArray<LPoint> lpDA = new DynamicArray<LPoint>();
...
pntDA.append(lpDA);    // ERRORE in compilazione

    public <E extends T> void append(DynamicArray<E> a) {
        ...     
    }

    public void append(DynamicArray<? extends T> a) {
        ...
    }

    public void copyTo(DynamicArray<T> a) {
        int size = a.getSize();
        int length = array.length;
        if (size < length) a.setSize(length);
        for (int i = 0 ; i < length ; i++)
            a.set(i, array[i]);
    }

DynamicArray<Point> pntDA = new DynamicArray<Point>();
DynamicArray<Point> pntDA2 = new DynamicArray<Point>();
DynamicArray<LPoint> lpDA = new DynamicArray<LPoint>();
...
pntDA.copyTo(pntDA2);     // OK 
lpDA.copyTo(pntDA);       // ERRORE in compilazione

    public void copyTo(DynamicArray<? super T> a) {
        ...
    }

public static <T extends Comparable<? super T>> T min(T[] a) { 
    ...
}

LPoint[] lpA = ...
LPoint minLP = min(lpA);

public class Test {
    public static <T> void copy(DynamicArray<? super T> dst, DynamicArray<? extends T> src) {
        int size = src.getSize();
        if (dst.getSize() < size) dst.setSize(size);
        for (int i = 0 ; i < size ; i++) 
            dst.set(i, src.get(i));
    }
    public static <T> void copy2(DynamicArray<T> dst, DynamicArray<? extends T> src) {
        // omessa perché uguale a quella del metodo copy()
    }
    public static <T> void copy3(DynamicArray<? super T> dst, DynamicArray<T> src) {
        // omessa perché uguale a quella del metodo copy()
    }
    public static <T> void copy4(DynamicArray<T> dst, DynamicArray<T> src) {
        // omessa perché uguale a quella del metodo copy()
    }
}

DynamicArray<Object> objDA = new DynamicArray<Object>();
DynamicArray<Number> numDA = new DynamicArray<Number>();
DynamicArray<Integer> intDA = new DynamicArray<Integer>();
...
copy(objDA, intDA);        // T è inferito essere Integer
copy2(objDA, intDA);       // T è inferito essere Object
copy3(objDA, intDA);       // T è inferito essere Integer
copy4(objDA, intDA);       // ERRORE in compilazione

copy(intDA, objDA);        // ERRORE in compilazione

Test.<Object>copy(objDA, intDA);
Test.<Number>copy(objDA, intDA);
Test.<Integer>copy(objDA, intDA);

Test.<Object>copy2(objDA, intDA);
Test.<Number>copy2(objDA, intDA);   // ERRORE in compilazione
Test.<Integer>copy2(objDA, intDA);  // ERRORE in compilazione

Test.<Object>copy3(objDA, intDA);   // ERRORE in compilazione
Test.<Number>copy3(objDA, intDA);   // ERRORE in compilazione
Test.<Integer>copy3(objDA, intDA);

Test.<Object>copy4(objDA, intDA);   // ERRORE in compilazione
Test.<Number>copy4(objDA, intDA);   // ERRORE in compilazione
Test.<Integer>copy4(objDA, intDA);  // ERRORE in compilazione

public class Test {
    public static double sum(DynamicArray<? extends Number> a) {
        double sum = 0;
        int n = a.getSize();
        for (int i = 0 ; i < n ; i++)
            sum += a.get(i).doubleValue();    // unboxing
        return sum;
    }
}

DynamicArray<Integer> ints = new DynamicArray<Integer>();
DynamicArray<Float> floats = new DynamicArray<Float>();
DynamicArray<Number> nums = new DynamicArray<Number>();
DynamicArray<String> strs = new DynamicArray<String>();
...
double tot = sum(ints);
tot = sum(floats);
tot = sum(nums);
tot = sum(strs);       // ERRORE in compilazione

                    -----------
                    | Pair<?> |
                    -----------
                        Δ
                        |
       ------------------------------------------
       |                                        |
----------------                   --------------------------
| Pair<Object> |                   | Pair<? extends Number> |
----------------                   --------------------------
                                                Δ
                                                |
                               ----------------------------------
                               |                                |
                    ---------------------------         ----------------
                    | Pair<? extends Integer> |         | Pair<Number> |
                    ---------------------------         ----------------
                               Δ
                               |
                       -----------------
                       | Pair<Integer> |
                       -----------------

                     -----------
                     | Pair<?> |
                     -----------
                          Δ
                          |
              -------------------------
              | Pair<? super Integer> |
              -------------------------
                          Δ
                          |
        --------------------------------------
        |                                    |
-----------------                 ------------------------
| Pair<Integer> |                 | Pair<? super Number> |
-----------------                 ------------------------
                                             Δ
                                             |
                                  -------------------------
                                  |                       |
                          ----------------         ----------------
                          | Pair<Number> |         | Pair<Object> |
                          ----------------         ----------------

DynamicArray<?> da = new DynamicArray<?>();        // ERRORE in compilazione

DynamicArray<Pair<?>> pairDA = new DynamicArray<Pair<?>>();
pairDA.setSize(10);
pairDA.set(0, new Pair<Integer>(1, 2));
pairDA.set(1, new Pair<String>("a", "b"));
Pair<Integer> intPair = null;
intPair = pairDA.get(0);           // ERRORE in compilazione
Pair<Object> objPair = null;
objPair = pairDA.get(1);           // ERRORE in compilazione
Pair<?> unknown = pairDA.get(0);

DynamicArray<Pair<? extends Number>> numPairDA = new DynamicArray<Pair<? extends Number>>();
numPairDA.setSize(10);
numPairDA.set(0, new Pair<Integer>(1, 2));
numPairDA.set(1, new Pair<String>("a", "b"));    // ERRORE in compilazione
intPair = numPairDA.get(0);        // ERRORE in compilazione
Pair<Number> numPair = null;
numPair = numPairDA.get(0);        // ERRORE in compilazione

Pair<? extends Number> extNumPair = numPairDA.get(0);
        
extNumPair = intPair;
Pair<? super Integer> supIntPair = numPair;
supIntPair = extnumPair;           // ERRORE in compilazione
Pair<? super Number> supNumPair = null;
supIntPair = supNumPair;
supNumPair = supIntPair;           // ERRORE in compilazione
unknown = supIntPair;
unknown = extNumPair;
supIntPair = objPair;

Esercizi

public class Test {
    public static void main(String[] args) {
        DynamicArray<String> strDA = new DynamicArray<String>();
        strDA.setSize(10);
        strDA.set(0, "a");
        DynamicArray<?> da = strDA;
        da.set(0, "b");
        Object o = da.get(0);
        String s = da.get(0);
        DynamicArray<? extends String> sDA = strDA;
        sDA.set(0, "c");
        String s2 = sDA.get(0);
    }
}

public class Test {
    public static void main(String[] args) {
        DynamicArray<Integer> intDA = new DynamicArray<Integer>();
        intDA.setSize(10);
        intDA.set(0, 12);
        DynamicArray<? super Integer> supIDA = intDA;
        supIDA.set(1, 17);
        Integer intO = supIDA.get(0);
        DynamicArray<?> da = new DynamicArray<? extends Integer>();
        DynamicArray<?> da2 = new DynamicArray<DynamicArray<?>>();
    }
}

Iterable e for-each

public interface Iterable<E> {
        // ritorna un iteratore per elementi di tipo E
    Iterator<E> iterator();
}

public interface Iterator<E> {
        // ritorna true se ci sono ancora elementi da visitare
    boolean hasNext();
        // ritorna il prossimo elemento
    E next();
        // rimuove l'elemento ritornato dall'ultima invocazione di next()
    void remove();
}

import java.util.*;

public class ACollection<E> implements Iterable<E> {
    private E[] array;         //Array che mantiene gli elementi della collezione
    private int size;          //Numero di elementi presenti nella collezione
    private int modCount = 0;  //Contatore delle modifiche (serve all'iteratore)
        //Costruisce una collezione vuota
    public ACollection() {
        array = (E[]) new Object[0];
        size = 0;
    }
        //Metodo ausiliario che ritorna il primo indice dell'array che contiene
    private int find(E x) {       //l'elemento x, se non è presente ritorna -1.
        for (int i = 0 ; i < array.length ; i++)
            if (x == null ? array[i] == null : array[i].equals(x))
                return i;
        return -1;
    }
        //Metodo ausiliario che rimuove l'elemento in posizione i
    private void remove(int i) {
        array[i] = array[--size];
        modCount++;
    }
        //Ritorna true se l'elemento x è contenuto nella collezione
    public boolean contains(E x) {
        return (find(x) != -1);
    }
        //Aggiunge l'elemento x alla collezione (anche se è già presente)
    public void add(E x) {
        if (array.length == size)
            array = Arrays.copyOf(array, (3*size)/2 + 1);
        array[size++] = x;
        modCount++;
    }
        //Aggiunge alla collezione tutti gli elementi passati come argomenti
    public void addAll(E...a) {
        for (int i = 0 ; i < a.length ; i++) add(x);
    }
        //Rimuove dalla collezione la prima occorrenza dell'elemento x e ritorna true,
    public boolean remove(E x) {        //se non è presente ritorna false.
        int i = find(x);
        if (i != -1) {
            remove(i);
            return true;
        } else return false;
    }
        //Ritorna il numero di elementi della collezione
    public int size() { return size; }

        //Classe nidificata statica che implementa l'iteratore
    private static class Itr<T> implements Iterator<T> {
        private ACollection<T> coll;    //La collezione da iterare
        private int cursor = 0;         //Indice del prossimo elemento
        private int lastRet = -1;       //Indice dell'ultimo elemento ritornato, se non c'è -1.
        private int expectedModCount;   //Il conteggio atteso delle modifiche
            //Costruisce un iteratore per la collezione c
        private Itr(ACollection<T> c) {
            coll = c;
            expectedModCount = coll.modCount;    //Registra il conteggio attuale delle modifiche
        }
            //Controlla che non siano state fatte delle modifiche dall'esterno alla collezione
        private void checkForModification() {          //da quando l'iteratore è stato creato.
            if (expectedModCount != coll.modCount)
                throw new ConcurrentModificationException();
        }
            //Implementa il metodo dell'interfaccia Iterator
        public boolean hasNext() {
            checkForModification();
            return (cursor < coll.size);
        }
            //Implementa il metodo dell'interfaccia Iterator
        public T next() {
            if (!hasNext())
                throw new NoSuchElementException();
            lastRet = cursor;
            return coll.array[cursor++];
        }
            //Implementa il metodo dell'interfaccia Iterator
        public void remove() {
            checkForModification();
            if (lastRet == -1)
                throw new IllegalStateException();
            coll.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = coll.modCount;    //Aggiorna il conteggio delle modifiche
        }
    }

        //Implementa il metodo dell'interfaccia Iterable
    public Iterator<E> iterator() {
        return new Itr<E>(this);
    }
}

for (Type v : set-expr)
    <istruzione o blocco di istruzioni>

static double average(int[] values) {
    double sum = 0.0;
    for (int val : values) 
        sum += val;
    return sum/values.length;
}

    for (int val : values) 
        sum += val;

    for (int i = 0 ; i < values.length ; i++)
        sum += values[i];

static <E> int countRep(E[] a, int r) {
    int count = 0;
    for (E x : a) {    //Per ogni x nell'array a
        int c = 0;
        for (E y : a)    //Conta il numero di ripetizioni di x
            if (x != null ? x.equals(y) : y == null) c++;
        if (c == r) count++;
    }
    return count/r;
}

static <E> void print(ACollection<E> coll) {
    for (E x : coll)
        System.out.println(x);
}

    for (Iterator<E> iter = coll.iterator() ; iter.hasNext() ; )
        System.out.println(iter.next());

import static java.lang.System.*;

public static void main(String[] args) {
    ACollection<String> frutti = new ACollection<String>();
    frutti.addAll("Mela", "Arancia", "Pera", "Limone", "Melone", "Limone", "Pera");

        //Stampa il numero massimo di ripetizioni di un frutto
    int maxRip = 0;
    for (String f1 : frutti) {
        int c = 0;
        for (String f2 : frutti)
            if (f1.equals(f2)) c++;
        if (c > maxRip) maxRip++;
    }
    out.println("Numero massimo di ripetizioni: "+maxRip);

        //Rimuove tutti i frutti di lunghezza maggiore di 4
    for (Iterator<String> i = frutti.iterator() ; i.hasNext() ; )
        if (i.next().length() > 4) i.remove();

        //Stampa i frutti rimasti
    for (String f : frutti)
        out.print(f+" ");
    out.println();
}

• Non può avere modificatori di accesso.
• Può accedere a tutti le variabili, campi e metodi che sono visibili nel blocco in cui la classe è definita. L'unica restrizione è che una variabile locale (o un parametro di metodo) sono accessibili solo se sono dichiarati final.
• I campi e i metodi di una classe locale nascondono (cioè, rendono inaccessibili) le variabili, i campi e i metodi che hanno lo stesso nome. In particolare, un metodo della classe locale nasconde tutti i metodi con lo stesso nome della classe che la contiene (anche se hanno signature differenti).

import java.util.*;

public class ACollection<E> implements Iterable<E> {
    private E[] array;
    private int size;
    private int modCount = 0;

    //Costruttore e metodi find(), contains(), add(), addAll(), remove() e size() omessi
    
    private void remove(int i) {
        array[i] = array[--size];
        modCount++;
    }

    public Iterator<E> iterator() {
        final ACollection coll = this;    //Serve per far sì che la classe Itr possa
                                          //accedere al metodo remove(int) di ACollection.
        class Itr implements Iterator<E> {
            private int cursor = 0;
            private int lastRet = -1;
            private int expectedModCount = modCount;
                //Controlla che non siano state fatte delle modifiche alla collezione
            private void checkForModification() {
                if (expectedModCount != modCount)
                    throw new ConcurrentModificationException();
            }
                //Implementa il metodo dell'interfaccia Iterator
            public boolean hasNext() {
                checkForModification();
                return (cursor < size);
            }
                //Implementa il metodo dell'interfaccia Iterator
            public E next() {
                if (!hasNext())
                    throw new NoSuchElementException();
                lastRet = cursor;
                return array[cursor++];
            }
                //Implementa il metodo dell'interfaccia Iterator
            public void remove() {
                checkForModification();
                if (lastRet == -1)
                    throw new IllegalStateException();
                coll.remove(lastRet);    //Metodo remove(int) della classe ACollection
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            }
        }
        
        return new Itr();
    }
}

    new NomeClasse(<eventuali parametri>) {    //NomeClasse è il nome della classe astratta
        <corpo della classe anonima>           //I parametri sono quelli di un costruttore
    }                                          //della classe astratta

    new NomeInterfaccia() {
        <corpo della classe anonima>
    }

    public Iterator<E> iterator() {
        final ACollection coll = this;
                                          
        return new Iterator<E>() {
            private int cursor = 0;
            private int lastRet = -1;
            private int expectedModCount = modCount;
                //Controlla che non siano state fatte delle modifiche alla collezione
            private void checkForModification() {
                if (expectedModCount != modCount)
                    throw new ConcurrentModificationException();
            }
                //Implementa il metodo dell'interfaccia Iterator
            public boolean hasNext() {
                checkForModification();
                return (cursor < size);
            }
                //Implementa il metodo dell'interfaccia Iterator
            public E next() {
                if (!hasNext())
                    throw new NoSuchElementException();
                lastRet = cursor;
                return array[cursor++];
            }
                //Implementa il metodo dell'interfaccia Iterator
            public void remove() {
                checkForModification();
                if (lastRet == -1)
                    throw new IllegalStateException();
                coll.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            }
        };
    }

Esercizi

public class Test {
    public static void main(String[] args) {
        ACollection<Integer> coll = new ACollection<Integer>();
        coll.addAll(1, 2, 3, 4, 5, 2, 1);
        for (Integer k : coll) {
            if (k % 2 == 0) 
                coll.remove(k);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        ACollection<String> coll = new ACollection<String>();
        coll.addAll("A", "AB", "BB", "C", "B");
        for (String s1 : coll) {
            for (Iterator<String> i = coll.iterator() ; i.hasNext() ; ) {
                String s2 = i.next();
                if (!s1.equal(s2) && s1.startsWith(s2))
                    i.remove();
            }
        }
    }
}

Il framework Collections

   
                                    ...............             
                                    : Iterable<E> :
                                    ...............
                                           Λ
                                           |
                                   .................
                                   : Collection<E> :
                                   .................
                                           |
                                           Λ
                 -------------------------------------------------------
                 |                                 |                   |
            ..........                        ...........         ............
            : Set<E> :                        : List<E> :         : Queue<E> :
            ..........                        ...........         ............
                 |                                 |                   |
                 Λ                                 Λ                   |
       ---------------------                 --------------            |
       |                   |                 |            |            |
................    --------------    ----------------    |            |
: SortedSet<E> :    | HashSet<E> |    | ArrayList<E> |    |            |
................    --------------    ----------------    --------------
       Λ                                                        Λ                
       |                                                        |
 --------------                                         -----------------
 | TreeSet<E> |                                         | LinkedList<E> |
 --------------                                         -----------------
                            .............
                            : Map<K, V> :
                            .............
                                  Λ 
                                  |
                          -----------------
                          | HashMap<K, V> |
                          -----------------

Iterable<E>

È l'interfaccia per iterare sugli elementi di una collezione che abbiamo già descritto.

Collection<E>

Interfaccia di base per tutti i tipi di collezione. Definisce i metodi comuni, come add(), contains(), remove(), size(), etc. Rappresenta una collezione generica che può contenere anche ripetizioni dello stesso elemento e gli elementi non hanno alcun ordinamento.

Set<E>

Interfaccia per un insieme di elementi (cioè, non può contenere elementi duplicati). Non mantiene alcun ordinamento.

SortedSet<E>

Interfaccia per un insieme ordinato di elementi.

List<E>

Interfaccia per una collezione dove gli elementi sono mantenuti in un ordine determinato dal modo in cui gli elementi sono aggiunti o rimossi.

Queue<E>

Interfaccia per una collezione che mantiene gli elementi ordinati come in una coda (FIFO).

Map<K,V>

Interfaccia per una mappa. Una mappa è una collezione di associazioni (k, v), cioè coppie, dove il primo elemento k è detto chiave (key) e il secondo elemento v è detto valore (value). È garantito che non ci sono due associazioni che "mappano" la stessa chiave in due valori (uguali o diversi). Sebbene una mappa possa essere vista come una particolare collezione, non estende l'interfaccia di base Collection<E>.

HashSet<E>

Implementazione dell'interfaccia Set<E> tramite tabelle hash.

ArrayList<E>

Implementazione dell'interfaccia List<E> tramite array.

TreeSet<E>

Implementazione dell'interfaccia SortedSet<E> tramite alberi binari di ricerca bilanciati.

LinkedList<E>

Implementazione delle interfacce List<E> e Queue<E> tramite liste bidirezionali (doubly-linked list). In realtà questa classe implementa una interfaccia che estende Queue<E>, chiamata Deque<E> (deque sta per "double ended queue"), la quale permette inserimenti e rimozioni da entrambe le estremità. Quindi permette di rappresentare non solo strutture FIFO, cioè code, ma anche strutture LIFO, cioè pile.

HashMap<K,V>

Implementazione dell'interfaccia Map<K,V> tramite tabelle hash.

boolean add(E elem)

Aggiunge l'elemento elem alla collezione. Se la collezione permette duplicati, il metodo ritorna sempre true. Se invece la collezione non permette duplicati (come Set), e un elemento equivalente ad elem è già presente, il metodo ritorna false.

boolean contains(Object elem)

Ritorna true se la collezione contiene un elemento equivalente a elem. Altrimenti ritorna false.

boolean remove(Object elem)

Rimuove un elemento equivalente a elem dalla collezione e ritorna true se una occorrenza di tale elemento è stata rimossa. Altrimenti ritorna false.

int size()

Ritorna il numero di elementi contenuti nella collezione.

Iterator iterator()

Ritorna un iteratore per scandire gli elementi della collezione.

    public int hashCode()

import java.io.*;
import java.util.*;
import static java.lang.System.*;

public class Example_Set {
        //Ritorna un insieme che contiene gli interi del file pathname
    public static Set<Integer> readSet(String pathname) throws FileNotFoundException {
        Scanner scan = new Scanner(new File(pathname));
        Set<Integer> set = new HashSet<Integer>();
        while (scan.hasNextInt())
            set.add(scan.nextInt());
        return set;
    }
    public static void main(String[] args) throws FileNotFoundException {
        if (args.length != 2) return;
        Set<Integer> set1 = readSet(args[0]);   //Legge il primo insieme
        Set<Integer> set2 = readSet(args[1]);   //Legge il secondo insieme
        int count = 0;
        for (Integer i : set1)                  //Conta gli interi del primo insieme
            if (!set2.contains(i)) count++;     //non contenuti nel secondo.
        if (count == 0)
            out.println("Il primo insieme è contenuto nel secondo");
        else
            out.println("Interi del primo insieme non contenuti nel secondo:"+count);
    }
}

E first()

Ritorna il primo elemento dell'insieme.

E last()

Ritorna l'ultimo elemento dell'insieme.

import java.io.*;
import java.util.*;
import static java.lang.System.*;

public class. Example_SortedSet {
    public static void main(String[] args) throws FileNotFoundException {
        if (args.length != 3) return;
        Scanner scan = new Scanner(new File(args[0]));
        SortedSet<String> set = new TreeSet<String>();  //Crea un insieme ordinato
        while (scan.hasNextLine())                      //che contiene le stringhe
            set.add(scan.nextLine());                   //distinte del file.
        out.println("Prima stringa: \""+set.first()+"\"");
        out.println("Ultima stringa: \""+set.last()+"\"");
        String s1 = args[1], s2 = args[2];
        out.println("Stringhe comprese tra \""+s1+"\" e \""+s2+"\":");
        for (String s : set) {               //Stampa le stringhe comprese tra s1 e s2
            if (s.compareTo(s2) > 0) break;
            if (s.compareTo(s1) >= 0)
                out.println(s);
        }
    }
}

void add(int index, E elem)

Aggiunge l'elemento elem in posizione index spostando di una posizione in avanti tutti gli elementi che si trovavano nelle posizioni da index in poi.

E set(int index, E elem)

Sostituisce l'elemento in posizione index con elem e ritorna l'elemento sostituito.

E get(int index)

Ritorna l'elemento in posizione index.

E remove(int index)

Rimuove e ritorna l'elemento in posizione index. Gli eventuali elementi successivi sono spostati di una posizione indietro.

Iterator<E> iterator()

Ritorna un iteratore che scandisce gli elementi secondo l'ordine della sequenza.

import java.io.*;
import java.util.*;
import static java.lang.System.*;

public class Example_List {
        //Ritorna una lista che contiene le linee del file pathname
    public static List<String> readList(String pathname) throws FileNotFoundException {
        Scanner scan = new Scanner(new File(pathname));
        List<String> list = new ArrayList<String>();
        while (scan.hasNextLine())          //Aggiunge le linee del file
            list.add(scan.nextLine());      //nella lista, nell'ordine.
        return list;
    }
    public static void main(String[] args) throws FileNotFoundException {
        if (args.length != 2) return;
        List<String> list1 = readList(args[0]);
        List<String> list2 = readList(args[1]);
        int curr = 0, n = list2.size();
        for (String s : list1) {                     //Cerca ogni linea della prima lista
            int i = curr;                            //nella seconda lista a partire dalla
            while (i < n && !s.equals(list2.get(i))) //posizione successiva a quella della
                i++;                                 //linea precedente.
            if (i < n) curr = i + 1;
            else {
                out.println("Il primo file NON è una sottosequenza del secondo file");
                return;
            }
        }
        out.println("Il primo file È una sottosequenza del secondo file");
    }
}

boolean offer(E elem)

Aggiunge l'elemento elem in coda e se ha successo ritorna true, altrimenti ritorna false. Questo metodo è preferibile al metodo add() quando la coda può rigettare l'aggiunta di un elemento, ad esempio se è una coda con capacità limitata.

E peek()

Ritorna l'elemento di testa della coda (senza rimuoverlo), se la coda è vuota ritorna null.

E poll()

Ritorna e rimuove l'elemento di testa della coda, se la coda è vuota ritorna null.

V put(K key, V value)

Aggiunge l'associazione (key, value) alla mappa. Se la chiave key aveva già un valore associato questo è sostituito con il nuovo valore value e il vecchio valore è ritornato. Se non c'era una associazione precedente, aggiunge quella nuova e ritorna null.

V get(Object key)

Ritorna il valore a cui la chiave key è associata o null se tale valore non c'è.

boolean containsKey(Object key)

Ritorna true se la mappa contiene una associazione con la chiave key. A differenza del metodo get() questo metodo permette di distinguere il caso in cui la chiave non ha un valore associato dal caso in cui ha associato il valore null.

V remove(Object key)

Rimuove l'associazione della chiave key e ritorna il valore che era associato alla chiave. Se la chiave non è associata a nessun valore, ritorna null.

Set<K> keySet()

Ritorna una vista (view) dell'insieme delle chiavi della mappa. Il fatto che è una vista dell'insieme delle chiavi significa che l'insieme è supportato dalla mappa stessa e cambiamenti della mappa si riflettono sull'insieme e viceversa. Se la mappa viene modificata mentre si sta effettuando una iterazione dell'insieme delle chiavi (eccetto che la modifica sia dovuta al metodo remove() dell'iteratore) il risultato dell'iterazione è indefinito. L'insieme ritornato supporta tutte le operazioni eccetto quelle di aggiunta di nuove chiavi.

int size()

Ritorna il numero di associazioni contenute nella mappa.

import java.util.*;
import static java.lang.System.*;

public class Example_Map {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        out.print("Digita un intero: ");
        int n = in.nextInt();
        Map<Integer,Integer> factors = new HashMap<Integer,Integer>();
        int k = 2;                                        //Iniziando da 2 cerca tutti i
        while (n > 1) {                                   //fattori primi di n e per ognuno
            while (n > 1 && (n % k) == 0) {               //conta il numero di volte che
                Integer h = factors.get(k);               //divide n. Mantieni i fattori
                factors.put(k, (h != null ? h + 1 : 1));  //e le loro molteplicità nella
                n /= k;                                   //mappa factors.
            }
            k++;
        }
        for (Integer h : factors.keySet()) {          //Scorri le chiavi della mappa
            Integer m = factors.get(h);               //(cioè i fattori) e stampali
            out.print(h+(m > 1 ? "^"+m : "")+" ");    //insieme con i loro valori
        }                                             //(cioè le molteplicità).
        out.println();
    }
}

import java.util.*;

public class HashTree<N> implements Iterable<N> {
    private N root;
    private final Map<N,N> parent = new HashMap<N,N>();
    private final Map<N,HashSet<N>> children = new HashMap<N,HashSet<N>>();
        //Crea un albero con un solo nodo, la radice
    public HashTree(N root) {
        this.root = root;
        parent.put(root, null);
        children.put(root, new HashSet());
    }
        //Aggiunge il figlio child al nodo p
    public boolean addChild(N p, N child) {
        if (p == null || child == null || !parent.containsKey(p) || parent.containsKey(child))
            throw new IllegalArgumentException();
        if (children.get(p).contains(child))
            return false;
        parent.put(child, p);
        children.get(p).add(child);
        children.put(child, new HashSet<N>());
        return true;
    }
        //Ritorna la radice dell'albero
    public N getRoot() {
        return root;
    }
        //Ritorna true se u è un nodo dell'albero
    public boolean isNode(N u) {
        return parent.containsKey(u);
    }
        //Ritorna il genitore del nodo u
    public N getParent(N u) {
        if (!parent.containsKey(u))
            throw new IllegalArgumentException();
        return parent.get(u);
    }
        //Ritorna i figli del nodo u in un insieme creato ex novo
    public Set<N> getChildren(N u) {
        if (!parent.containsKey(u))
            throw new IllegalArgumentException();
        return (Set<N>)children.get(u).clone();
    }
        //Iteratore sui nodi dell'albero
    public Iterator<N> iterator() {
        return parent.keySet().iterator();
    }
}

import java.util.*;
import static java.lang.System.*;

public class Test {
        //Stampa a video l'albero tree
    public static <N> void printTree(HashTree<N> tree) {
        printTreeRecursive(tree, tree.getRoot(), "", false);
    }
        //Metodo ricorsivo che stampa ricorsivamente l'albero tree a partire dal nodo u
    private static <N> void printTreeRecursive(HashTree<N> tree, N u, 
                                                  String prefix, boolean isLast) {
        if (!prefix.isEmpty()) out.print(prefix + "---");
        out.println(u);
        Set<N> children = tree.getChildren(u);
        if (isLast) {
            prefix = prefix.substring(0, prefix.length() - 1)+ " ";
            if (children.size() == 0) out.println(prefix);
        }
        prefix += "    |";
        for (Iterator<N> i = children.iterator() ; i.hasNext() ; )
            printTreeRecursive(tree, i.next(), prefix, !i.hasNext());
    }
    public static void main(String[] args) {
        HashTree<String> tree = new HashTree<String>("Informatica");
        tree.addChild("Informatica", "Software");
        tree.addChild("Informatica", "Hardware");
        tree.addChild("Hardware", "Memorie");
        tree.addChild("Hardware", "Processori");
        tree.addChild("Hardware", "Architetture");
        tree.addChild("Software", "Sistemi Operativi");
        tree.addChild("Software", "Basi di Dati");
        tree.addChild("Software", "Elaborazione di testi");
        tree.addChild("Software", "Elaborazione di immagini");
        tree.addChild("Software", "Algoritmi");
        tree.addChild("Software", "Linguaggi");
        tree.addChild("Linguaggi", "Imperativi");
        tree.addChild("Linguaggi", "Funzionali");
        tree.addChild("Linguaggi", "Orientati agli Oggetti");
        tree.addChild("Imperativi", "C");
        tree.addChild("Imperativi", "Pascal");
        tree.addChild("Orientati agli Oggetti", "C++");
        tree.addChild("Orientati agli Oggetti", "Java");
        tree.addChild("Orientati agli Oggetti", "Smalltalk");
        tree.addChild("Basi di Dati", "SQL");
        tree.addChild("Basi di Dati", "Data Mining");
        tree.addChild("Sistemi Operativi", "Unix");
        tree.addChild("Sistemi Operativi", "Linux");
        tree.addChild("Sistemi Operativi", "MacOS X");
        printTree(tree);
    }
}

Informatica
    |---Software
    |    |---Basi di Dati
    |    |    |---SQL
    |    |    |---Data Mining
    |    |     
    |    |---Elaborazione di immagini
    |    |---Sistemi Operativi
    |    |    |---Linux
    |    |    |---Unix
    |    |    |---MacOS X
    |    |     
    |    |---Linguaggi
    |    |    |---Imperativi
    |    |    |    |---Pascal
    |    |    |    |---C
    |    |    |     
    |    |    |---Funzionali
    |    |    |---Orientati agli Oggetti
    |    |         |---C++
    |    |         |---Java
    |    |         |---Smalltalk
    |    |          
    |    |---Algoritmi
    |    |---Elaborazione di testi
    |     
    |---Hardware
         |---Processori
         |---Architetture
         |---Memorie

Esercizi

Lista di input (lista di stringhe)     Mappa di output
("A", "B", "A", "C", "C", "D")         {("A", (0, 2)), ("B", (1)), ("C", (3, 4)), ("D", (5))}

Mappa di input Map<String, Integer> e soglia 5        Mappa di output
{("A", 2), ("B", 5), ("C", 4), ("D", 6), ("F", 6)}    {("B", 5), ("D", 6), ("F", 6)}         

La trota apre la bocca sulla pera mentre la torta era mangiata dal ratto.
Eppur le rape erano toste e senza nesso, e questo testo era privo di senso.

[ratto, trota, torta]
[pera, apre, rape]
[toste, testo]
[nesso, senso]