lunedì 21 ottobre 2013

Q18

Given the directory structure that contains three directories: company, Salesdat, and Finance:

- Company
            - Salesdat
                        - Target.dat
            - Finance
                        - Salary.dat
                        - Annual.dat


And the code fragment :

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;

public class SearchApp extends SimpleFileVisitor<Path> {
       private final PathMatcher matcher;

       SearchApp() {
             matcher = FileSystems.getDefault().getPathMatcher("glob:*dat*");
       }

       void find(Path file) {
             Path name = file.getFileName();
             if (name != null && matcher.matches(name)) {
                    System.out.println(name);
             }
       }

       public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
             find(file);
             return FileVisitResult.CONTINUE;
       }

       public static void main (String [] args) throws IOException
                 
             SearchApp obj = new SearchApp();       
             Files.walkFileTree(Paths.get("//Company"), obj);
       }
}


If Company is the current directory, what is the result?



A.
Prints only Annual.dat



B.
Prints only Salesdat, Annual.dat
 

C.
Prints only Annual.dat, Salary.dat, Target.dat

D.
Prints at least Salesdat, Annual.dat, Salary.dat, Target.dat

Risposta C.

Per scorrere i file contenuti dentro una alberatura di directory si può utilizzare l’interfaccia FileVisitor.

Un modo più semplice è quello di estendere la classe SimpleFileVisitor che estende l’interfaccia e sovrascrivere poi i soli metodi che interessano.

In questo esempio viene sovrascritto il solo metodo visitFile che viene invocato nel momento in cui siamo sopra il file ispezionato.

L’applicazione dell’esempio crea un cammino, un walk, tramite walkFileTree . Nel modo scritto il cammino ha solo il punto di inizio e il fileVisitor, quindi significa che andrà a cercare in tutti i sottolivelli senza alcun limite.




Quindi entreremo in per ogni file visitFile al livello pari o inferiore al punto di inizio. Quindi andremo a visitare ogni file.

Per ogni file faremo il match, per vedere se rispetta la condizioni di ricerca che abbiamo espresso con la sintassi glob.

glob:*dat* significa che troveremo

·         Tutti i file con estensione .dat.
·         Tutti i file che contengono dat in qualunque punto del nome.

Quindi troveremo :

Annual.dat
Salary.dat
Target.dat

Ma troveremmo anche questi file:
datprova.txt
provadatprova.txt
dat
provadat
datprova
provadatprova


Invece non troveremo mai nessuna directory perché non andremo mai ad esaminarle.

Riferimenti:

 

giovedì 26 settembre 2013

Q17

Given:

import java.util.Scanner;

  public class Painting {
     public static void main(String[] args) {
          String input = "Pastel, *Enamel, Fresco, *Gouache";
          Scanner s = new Scanner(input);
          s.useDelimiter(",\\s*");
          while (s.hasNext()) {
                System.out.println(s.next());
          }
     }
  }

 

 What is the result?

 A.
 Paste1
 Ename1
 Fresco
 Gouache

 B.
 Paste1
 *Ename1
 Fresco
 *Gouache

 C.
 Pastel
 Ename1
 Fresco
 Gouache

 D.
 Pastel
 Ename1, Fresco
 Gouache


La risposta è B
Scanner è un semplice scanner di testo in grado di parsare tipi primitivi o String utilizzando le espressioni regolari.
Uno Scanner spezza l’ingresso in pezzi (token) a seconda del delimitatore stabilito, che di default è lo spazio.
I token risultanti possono poi essere convertiti in tipi diversi utilizzando i vari metodi next messi a disposizione.
Il delimitatore può essere cambiato tramite il metodo useDelimitator.
L’espressione usate nel delimitatore : è ",\\s*" .
\s equivale a [ \t\n\r]
[ \t] spazi e tabulazioni
\n  fine riga
\r ritorno a capo (CR)
* indica zero o più occorrenze (di un carattere o di un gruppo di caratteri)
Quindi s.useDelimiter(",\\s*"); va letta come :
Utilizza come nuovo delimitatore la virgola ( , ) seguita da un numero qualunque (anche zero) di spazi, tabulazioni fine riga o ritorni a capo. In pratica è un modo per includere ogni virgola della stringa. Nel token quindi finisce tutto ciò che non è la virgola che viene stampato quando si usa il metodo next.
Riferimenti:
 

Q16

How many Threads are created when passing task to an Executor instance?
 
A.
A new Thread is used for each task.

B.
A number of Threads equal to the number of CPUs Is used to execute tasks.

C.
A single Thread Is used to execute all tasks.

D.
A developer-defined number of Threads is used to execute tasks.

E.
A number of Threads determined by system load is used to execute tasks.

F.
The method used to obtain the Executor determines how many Threads are used to execute tasks.
La risposta è F.
Executor è la più semplice delle interfacce definite nel pacchetto java.util.concurrent, che serve a realizzare la programmazione concorrente. Fornisce un singolo metodo, execute,  progettato allo scopo di rimpiazzare la classica sintassi di basso livello per la creazione di un thread .
            (new Thread (r)) start ();
con
            e.execute (r);
Con r un oggetto Runnable ed e un Executor.

Tuttavia, la definizione di execute è meno specifica. Se il linguaggio di basso livello crea un nuovo thread e lo lancia immediatamente Executor può invece utilizzare un thread già esistente per eseguire r, crearne uno nuovo e lanciarlo come nella sintassi di basso livello o anche mettere r in una coda in attesa che un thread di lavoro diventi disponibile.
Riferimenti:




Q15

Which type of ExecutorService supports the execution of tasks after a fixed delay?
 

A.
DelayedExecutorService
 
B.
ScheduledExecutorService

C.
TimedExecutorService

D.
FixedExecutorService

E.
FutureExecutorService

 

Risposta B.
La java.util.concurrent.ScheduledExecutorService è una ExecutorService che può pianificare le attività da eseguire con un certo ritardo oppure che può eseguirle più volte con un intervallo tra le varie esecuzioni. Le operazioni vengono eseguite in modo asincrono da un thread di lavoro e non dal thread che gestisce il task della ScheduledExecutorService stessa.

Riferimenti :

 

 

mercoledì 25 settembre 2013

Q14


Given:

import java.util.*;
public class Flimmer  implements Pinkable {
             List <Tagger> t = new ArrayList<Tagger>();
       }
 
public class Flommer extends Flimmer {
             String s = "hey" ;
       }
 
public class Tagger implements Glommer {
       void doStuff(){ String s ="yo" ;}
}

public interface Glommer {}

public interface Pinkable {}


Which two statements concerning the OO concepts “is-a” and “has-a” are true?

A.
Flimmer is-a Glommer.

B.
Flommer has-a String.

C.
Tagger has-a Glommer.

D.
Flimmer is-a ArrayList.

E.
Tagger has-a doStuff().

F.
Tagger is-a Glommer.

 

 

La risposta è EF.

Nella programmazione orientata agli oggetti (e in generale nella rappresentazione della conoscenza) is-a indica una relazione dove una classe A è sottoclasse di una classe B (e B è superclasse di A) .
A is-a B indica che A è sotto tipo di B.
Un altro modo di specificare questo concetto è dire ogni oggetto che soddisfa le specifiche di A soddisfa anche le specifiche di B , perché le specifiche di B sono più leggere di quelle di A.
Invece has-a indica che un oggetto appartiene ad un altro oggetto. In Java ad esempio un attributo appartiene ad una classe e quindi :
A has-a B indica che la classe A ha un attributo B.
Ad esempio consideriamo queste tre classi :
public class Superclasse {}

public class Sottoclasse extends Superclasse{  }

public class Classe {
int attributo;
}

Possiamo scrivere :
·         Sottoclasse     is-a      Superclasse
·         Classe             has-a    attributo
Quindi :
A.
Flimmer is-a Glommer. NO
Stiamo dicendo che Flimmer è sotto tipo di Glommer ma non è vero perchè tra i due oggetti non c'è relazione.
Sarebbe vero dire Flimmer is-a Pinkable perchè in effetti Flimmer  implementa Pinkable e quindi ne è un sotto tipo.


B.
Flommer has a String. NO
Sarebbe giusto dire Flommer has-a s (che è di tipo String)

C.
Tagger has-a Glommer. NO
Per essere vero Tagger dovrebbe avere Glommer come attributo.

D.
Flimmer is-a ArrayList. NO
Flimmer non è certo un sotto tipo del tipo ArrayList!

E.
Tagger has a doStuff() OK
Questo è vero perchè in effetti Tagger possiede il metodo doStuff().

F.
Tagger is-a Glommer. OK
Questo è vero perchè Tagger è un sotto tipo di Glommer. Infatti Glommer è una interfaccia e Tagger la implementa.
Riferimenti:

martedì 24 settembre 2013

Q13

Given the Greetings.properties file, containing:

HELLO_MSG = Hello, everyone!
GOODBYE_MSG = Goodbye everyone!

 
And given:

public class ResourceApp {
       public void loadResourceBundle() {
             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);
             System.out.println(resource.getObject(1));
       }
       public static void main(String[] args) {
             new ResourcesApp().loadResourceBundle();
       }
}


What is the result?


A.
Compilation fails

B.
HELLO_MSG

C.
GOODGYE_NSG

D.
Hello, everyone!

E.
Goodbye everyone!

La risposta è A.
Infatti per come è scritto quel codice non compila per due motivi :
1)      Il metodo getObject() di ResourceBundle accetta solo String.
2)      Nel new ResourcesApp() c’è un errore infatti il tipo ResourcesApp non è definito.
Se invece si considera questo altro codice, in cui ResourcesApp si sostituisce con ResourceApp (senza la s) e l’argomento al metodo getObject si cambia da 1 ad “1” si ha una corretta compilazione:
import java.util.Locale;
import java.util.ResourceBundle;

 
public class ResourceApp {
       public void loadResourceBundle() {
             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);
             System.out.println(resource.getObject("1"));
       }

       public static void main(String[] args) {
             new ResourcesApps().loadResourceBundle();
       }
}
Per testare questo codice va creato un file di proprietà Greetings :
 
con il seguente codice :
HELLO_MSG = Hello, everyone!
GOODBYE_MSG = Goodbye everyone!

 
In questo caso il codice restituisce una eccezione a Runtime perché nel file di properties non esiste una risorsa con chiave “1”:

Exception in thread "main" java.util.MissingResourceException: Can't find resource for bundle java.util.PropertyResourceBundle, key 1

Il codice viene eseguito correttamente invece nel caso di richiamo di una chiave esistente , ad esempio  HELLO_MSG :

import java.util.Locale;
import java.util.ResourceBundle;

public class ResourceApp {
       public void loadResourceBundle() {
             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);
             System.out.println(resource.getObject("HELLO_MSG"));
       }
       public static void main(String[] args) {
             new ResourceApp().loadResourceBundle();
       }
}

in questo caso l’uscita è : Hello, everyone!.

Riferimenti: