input-output

[newutente]

Sto facendo degli esercizi sull'input-output e vorrei stampare a video quello che scrivo.
Questo è il codice scritto:

import java.io.IOException;
import java.util.Scanner;


public class EditorInterattivo {
    public static void main(String args[]) throws IOException {
        try (Scanner sc = new Scanner(System.in)) {
            String stringa = " ";
            while(sc.hasNext()) {
                stringa += " " + sc.next();
                System.out.println("hai digitato: " + stringa);
            }
        }
    }
}

Il problema è che Eclipse non mi visualizza nessun output, cioè io eseguo il programma ma non succede niente.
Il codice funziona anche perchè l'ho compilato ed eseguito da riga di comando però vorrei capire qual è il problema con Eclipse.

[newutente]

Come non detto, risolto. Semplicemente si era chiusa la scheda della Console e non mi ero accorto. Scusate.

[newutente]

Per quanto riguarda comunque il codice di prima ho modificato leggermente il blocco try in questo modo:

try (Scanner sc = new Scanner(System.in)) {
            String stringa = null;
            while(sc.hasNext()) {
                if(stringa.equals("fine")) {
                    System.out.println("programma terminato");
                    break;
                }
                stringa = sc.nextLine();
                System.out.println("hai digitato: " + stringa);
            }
}

Questo codice mi genera una NullPointerException. Questa cosa accade perchè utilizzo uno Scanner e il metodo hasNext() andrà a scandire un riferimento a null?
Faccio questa domanda perchè se utilizzo invece, anzichè lo Scanner, un InputStreamReader decorato con un BufferedReader questo non accade.

[Alex'87]

No, ti da eccezione perché stringa all'inizio vale null e appena fai stringa.equals esplode...

[newutente]

Quindi fa un controllo del tipo null=="fine" che di per se non ha senso e quindi da l'eccezione.

Ora vorrei cercare di chiarirmi un po' un dubbio che ho.
Questo è un esercizio che ho svolto che chiedeva di scrivere qualcosa da tastiera e poi salvare quel qualcosa su un file:

List<String> listaStringhe = new ArrayList<>();
        
        try (InputStreamReader lettore = new InputStreamReader(System.in);
             BufferedReader buffer = new BufferedReader(lettore)) {
            String stringa = null;
            stringa = buffer.readLine();
            while (stringa != null) {
                if(stringa.equals("fine")) {
                    System.out.println("programma terminato");
                    break;
                }
                System.out.println("hai digitato: " + stringa);
                listaStringhe.add(stringa);
                stringa = buffer.readLine();
                
            }
            
            File dir = new File("C:\\Users\\Utente\\Desktop\\JAVA\\src\\file");
            File file = new File(dir, "file creato.txt");
            FileWriter scrittore = new FileWriter(file);
            for(String parola : listaStringhe) {
                scrittore.write(parola + " | ");
            }
            scrittore.close();
                        
        }

L'esercizio l'ho svolto e funziona però ho un dubbio.
Leggendo sul manuale ho potuto capire che i Decorator sono sottoclassi che in genere hanno bisogno di agganciarsi ad un Component per poter funzionare.
Io nel mio esercizio ho utilizzato un Component (BufferedReader) agganciandolo ad un altro Component (InputStreamReader) e quindi usandolo come un Decorator e successivamente un Decorator (FileWriter) non agganciandolo a niente.
E' vero che l'esercizio l'ho svolto e funziona però sono andato più a intuito e rileggendo il manuale mi sembra che in questo teoria (quindi utilizzo del pattern Decorator) e pratica non coincidono.
Mi aiutate a capire?

[newutente]

L'esercizio l'ho svolto e funziona però ho un dubbio.
Leggendo sul manuale ho potuto capire che i Decorator sono sottoclassi che in genere hanno bisogno di agganciarsi ad un Component per poter funzionare.
Io nel mio esercizio ho utilizzato un Component (BufferedReader) agganciandolo ad un altro Component (InputStreamReader) e quindi usandolo come un Decorator e successivamente un Decorator (FileWriter) non agganciandolo a niente.
E' vero che l'esercizio l'ho svolto e funziona però sono andato più a intuito e rileggendo il manuale mi sembra che in questo teoria (quindi utilizzo del pattern Decorator) e pratica non coincidono.
Mi aiutate a capire?

Mi permetto di riproporvi il dubbio che ho sul pattern Decorator, non per mettervi fretta ma solo perchè vorrei continuare senza lasciarmi niente indietro.

[andbin]

Mi permetto di riproporvi il dubbio che ho sul pattern Decorator, non per mettervi fretta ma solo perchè vorrei continuare senza lasciarmi niente indietro.

Il pattern "Decorator" descrive lo scenario in cui ci sono una serie di oggetti denominati con i termini "componente", "componente concreto", "decoratore" e "decoratore concreto".

Nel caso del package java.io (modellato appunto sul Decorator), classi come FileReader, FileWriter, FileInputStream e FileOutputStream NON sono decoratori. Sono componenti concreti!
Per es. BufferedWriter è un decoratore, perché a) è-un Writer, e b) contiene (incapsula) un altro Writer.
Mentre FileWriter è un componente concreto, "finale" nel senso che opera su un qualcosa di ben preciso (esclusivamente su un file) e non incapsula "altro".

InputStreamReader invece è più un "adapter" che un "decorator", perché in effetti fa cambiare completamente faccia allo stream. Infatti contiene un InputStream ma InputStreamReader non è-un InputStream ma bensì un Reader.

[valia]

no, tu fai

String stringa =null;
            while(sc.hasNext()){
                if(stringa.equals("fine")){

stringa ancora non è inizializzata, provi a chiamare un metodo su un oggetto che ancora non hai valorizzato (quindi su null).
Va in eccezione stringa.equals, questo, indipendentemente da quanto vale quello con cui confronti.

Se ad esempio tu avessi fatto "fine".equals(stringa) avresti avuto false, senza eccezioni (vediamo se ti rendi conto del perché).

Riguardo al pattern: ti rispondo quando passa il mal di testa e ragiono meglio

[newutente]

Se ad esempio tu avessi fatto "fine".equals(stringa) avresti avuto false, senza eccezioni (vediamo se ti rendi conto del perché).

perchè "fine" è per così dire valorizzato quindi l'invocazione del metodo va a buon fine. nell'altro caso invece io sto cercando di invocare un metodo su qualcosa che non è valorizzato.
giusto?

[valia]

togli è così dire, in realtà a "fine" è associato un oggetto di tipo stringa, per cui chiamare un metodo su quello equivale a chiamare un metodo su una stringa correttamente inizializzata.
Restituisce false perché in pratica equals controlla se quello che passo non sia null: se null è sicuro che gli oggetti sono differenti, quindi ritorna subito false