[JAVA] java.lang.NullPointerException

[sisafra]

Ciao a tutti, sono alle prime armi con la programmazione in java..e tra un po' proverò a sostenere l'esame. all'università.. Programmare non mi è mai piaciuto, ma bisogna farlo..Il programma che posto qui è quindi, probabilmente, per molti di voi molto semplice..supera la fase di compilazione ma mi dà poi un errore in esecuzione..Potreste aiutarmi a risolvere il problema? Grazie



import java.util.Scanner;

interface CO
{ int size();
boolean isEmpty();
void enqueue(Comparable x);
Comparable dequeue();
void sort();
}

class MyCO implements CO
{ private Comparable[] v ;
private int vsize;
private int primo;
private int ultimo;

public MyCO()
{ Comparable[] v = new Comparable[1];
vsize = 0;
primo = 0;
ultimo = v.length-1;
}

public int size()
{ return vsize; }

public boolean isEmpty()
{ return (vsize==0); }

public void enqueue(Comparable x)
{ if ( x == null)
throw new IllegalArgumentException();
Comparable[] newv = new Comparable[vsize*2];
if (vsize == v.length) RIGA 34
System.arraycopy(v, 0, newv, 0, vsize);
newv = v;
v[ultimo] = x;
ultimo++;
vsize++;
}

public Comparable dequeue()
{ if (vsize == 0)
throw new IllegalArgumentException();
Comparable rem = v[primo];
vsize--;
return rem;
}

public void sort()
{ Comparable[] t = new Comparable[vsize];
for ( int i = 0; i<v.length; i++)
{ int minimo = i;
for ( int j = i+1; j<v.length; j++)
if (v[minimo].compareTo(v[j]) >0)
minimo = j;
Comparable temp = v[minimo];
v[minimo] = v[i];
v[i] = temp;
}
}
}

/* Scrivere una classe Main.java di prova che:
– crei due esemplari della classe MiaCO di nome uno e due
– legga dall'ingresso standard una sequenza di numeri interi
in ordine casuale (un dato per riga), li
inserisca sia nella coda uno che nella coda due. Esegua 5 (cinque)
operazioni di dequeue() sulla coda uno, ordini la coda e la vuoti
trasferendone il contenuto sull'uscita standard (un dato per riga, i dati d
ovranno risultare ordinati), trasferisca sull'uscita standard una riga vuota
e vuoti la coda due trasferendo i dati sull'uscita standard, uno per riga.
In questo caso i dati in uscita dovranno essere nello stesso ordine dei dati in ingresso
*/


public class Main
{ public static void main (String[] args)
{ MyCO uno = new MyCO();
MyCO due = new MyCO();
Scanner c = new Scanner (System.in);
while (c.hasNext())
{ Integer w = new Integer(c.nextLine());
uno.enqueue(w); RIGA 84
due.enqueue(w);

}
uno.dequeue();
uno.dequeue();
uno.dequeue();
uno.dequeue();
uno.dequeue();
uno.sort();
while (!uno.isEmpty())
System.out.println(uno.dequeue());
System.out.println();
while (!due.isEmpty())
System.out.println(due.dequeue());
}
}

L'errore lanciato è

Exception in thread "main" java.lang.NullPointerException
at MyCO.enqueue(Main.java:34)
at Main.main (Main.java:84)

Evidenzio nel codice le righe..se qualcuno può aiutarmi..la maggior parte dei programmi che scrivo superano la compilazione ma poi mi viene sempre fuori questo errore..cosa sbaglio??

[banryu79]

Ciao,
premesso che *NON* ti ho risolto l'esercizio, e che il codice postato qui sotto *NON E'* una soluzione al testo dell'esercizio, ci sono molte "sviste" nel codice.

Questo codice qui sotto è la copia del tuo, dove ci sono degli errori (sono tutti errori semantici, la sintassi era corretta) li ho commentati e subito sotto ho scritto una variante (colorata in marroncino).
Il primo errore che dovresti controllare è quello evidenziato in rosso, che poi è la causa della tua NullPointerException.
Però come vedi, ne ho trovati molti altri (darebbero origine a altre eccezioni e inconsistenze). Prova a ragionarci sopra.

import java.util.Scanner;

interface CO
{
    int size();
    boolean isEmpty();
    void enqueue(Comparable x);
    Comparable dequeue();
    void sort();
}


class MyCO implements CO
{
        private Comparable[] v ;
        private int vsize;
        private int primo;
//        private int ultimo;

    public MyCO() {

//        Comparable[] v = new Comparable[1];
        v = new Comparable[1];

        vsize = 0;
        primo = 0;
//        ultimo = v.length-1;
    }

    public int size() {
        return vsize;
    }

    public boolean isEmpty() {
//        return (vsize==0);
        return primo>=vsize;
    }

    public void enqueue(Comparable x) {
        if (x == null)
            throw new IllegalArgumentException();

//        Comparable[] newv = new Comparable[vsize*2];
//        if (vsize == v.length) //RIGA 34
//            System.arraycopy(v, 0, newv, 0, vsize);
//        newv = v;
        if (vsize == v.length) {
            Comparable[] newv = new Comparable[v.length*2];
            System.arraycopy(v, 0, newv, 0, vsize);
            v = newv;
        }

        v[vsize] = x;
//        ultimo++;
        vsize++;
    }

    public Comparable dequeue() {
//        if (vsize == 0)
        if (primo >= vsize)
            throw new IllegalArgumentException();
        Comparable rem = v[primo];
//        vsize--;
        primo++;
        return rem;
    }

//    public void sort() {
//        Comparable[] t = new Comparable[vsize];
////        for (int i=0; i<v.length; i++) {
//        for (int i=0; i<vsize-2; i++) {
//            int minimo = i;
////            for (int j=i+1; j<v.length; j++)
//            for (int j=i+1; j<vsize-1; j++)
//                if (v[minimo].compareTo(v[j]) > 0)
//                    minimo = j;
//            Comparable temp = v[minimo];
//            v[minimo] = v[i];
//            v[i] = temp;
//        }
//    }
    /**
     * Implementato come un insertion sort.
     */
    public void sort() {
        for(int i=1; i<vsize; i++) {
            Comparable tmp = v[i];
            int k = i;
            for(; k>0 && tmp.compareTo(v[k-1])<0; k--)
                v[k] = v[k-1];
            v[k] = tmp;
        }
    }
}


public class Main
{
    public static void main (String[] args) {
        MyCO uno = new MyCO();
        MyCO due = new MyCO();

        Scanner c = new Scanner (System.in);

//        while (c.hasNext()) {
//            Integer w = new Integer(c.nextLine());
//            uno.enqueue(w); //RIGA 84
//            due.enqueue(w);
//        }
        while(true) {
            try {
                Integer w = c.nextInt();
                uno.enqueue(w);
                due.enqueue(w);
            } catch(RuntimeException ex) {
                break;
            }
        }

        System.out.println();

        uno.sort();
        while (!uno.isEmpty())
            System.out.println(uno.dequeue());
        
        System.out.println();
        
        while (!due.isEmpty())
            System.out.println(due.dequeue());
    }
}

Per leggere i dati dallo standard input ho usato [Scanner].nextInt() assumendo che l'utente digiti solo valori interi, e le letture sono contenute in un ciclo infinito (while(true)) che cattura input finchè l'utente non digita e spedisce qualcosa di diverso da un numero intero (ho sfruttato il fatto che [Scanner].nextInt() lancia un'eccezione se il rpossimo token che legge non è un intero).

[sisafra]

Ciao, ti ringrazio molto, effettivamente l'errore che genera null è proprio STUPIDO, non ho mai fatto una cosa del genere -.-..e non me ne accorgevo nemmeno.. sarà che ero anche fusa da una giornata di programmazione..ora ragiono un po' sulle tue varianti..e vediamo se funziona..grazie davvero ..

[banryu79]

Originariamente inviato da sisafra

Ciao, ti ringrazio molto, effettivamente l'errore che genera null è proprio STUPIDO, non ho mai fatto una cosa del genere -.-..e non me ne accorgevo nemmeno.. sarà che ero anche fusa da una giornata di programmazione..ora ragiono un po' sulle tue varianti..e vediamo se funziona..grazie davvero ..

Commettere errori è normalissimo, nessuno scrive codice esente da difetti, specie se si sta imparando (sbagliando si impara, dice il proverbio ).

Il codice la sopra compila ed esegue senza errori, il problema è un altro (suppongo): per risolvere l'esercizio dovrai ripensare all'implementazione dell'interfaccia CO. L'attuale MyCO implementata è una struttura dati di tipo FIFO (una coda) solo che è implementata con un array che ha una politica di "resize" e mantenimento dello spazio un pochino bizzarra (cresce sempre, non recupera mai lo spazio inutilizzato).

Per darti uno spunto su cui riflettere, prova a pensare come cambia il tasso di crescita dell'array interno alla coda man mano che vengono allocati sempre più elementi (ad esempio 10, 100, o 1000 elementi) prima con il metodo attuale enque, e dopo con questa variante:

///////
'elements' è l'array di Comparable interno alla coda.
'head' è l'indice della testa (primo elemento della coda).
'tail' è l'indice della coda (indice dove inserire il prossimo elemento, ovvero l'indice sucessivo a quello dell'utimo elemento presente).
//////
if (head == tail) {
    int n = elements.length;
    int r = n - head; // number of elements to the right of head
    int newCapacity = n*2;
    Comparable[] arr = new Comparable[newCapacity];
    System.arraycopy(elements, head, arr, 0, r);
    System.arraycopy(elements, 0, arr, r, head);
    elements = arr;
    head = 0;
    tail = n;
}
///////

[sisafra]

..mi era stato chiesto dal testo dell'esercizio che l'array crescesse sempre.. -.- .. ma un'altra domanda..mi hai parlato di errori semantici, ma la sintassi era corretta..cioè vuoi dire errori di concetto??

[banryu79]

Originariamente inviato da sisafra

ma un'altra domanda..mi hai parlato di errori semantici, ma la sintassi era corretta..cioè vuoi dire errori di concetto??

Sì, esatto.
Ad esempio l'errore di assegnare, nel costruttore, l'array di Comparable appena allocato ad una variabile locale, invece che al membro di istanza della classe. La sintassi era corretta, è proprio la logica ad essere sbagliata (chiaramente questa in particolare è stata una svista).

..mi era stato chiesto dal testo dell'esercizio che l'array crescesse sempre.. -.- ..

Ma certo, infatti anche nello spezzone di codice che ti ho postato l'array cresce sempre; semplicemente ad ogni raddoppio della dimensione
recupera lo spazio inutilizzato delle 'celle' vuote dell'array posizionate a sinistra del puntatore della head, che sono diventate tali (inutilizzate) a seguito delle operazioni di "dequeue".
Quel codice non è farina del mio sacco: l'ho preso pari-pari dalla attuale implementazione della classe java.util.ArrayDeque del JDK.

[sisafra]

Ora dò un'occhiata al'ArrayDeque di cui parli..certo, ci vuole decisamente molta molta pratica, ma gli esercizi sono pochissimi, e i temi d'esame anche..non so dove andare a pescare qualcosa di utile per farmi entrare in testa le cose importanti.. Ti ringrazio molto comunque ..