Q29

Given the following incorrect program:

import java.util.concurrent.RecursiveTask;

class MyTask extends RecursiveTask<Integer> {

     final int low;final int high;

     static final int THRESHOLD =  /*--*/ ;

     MyTask (int low,int hight) {

          this.low=low;this.high=hight;

     }

     Integer computeDirectly() {

          return null;

     } /*..*/

protected void compute() {

     if (high - low <= THRESHOLD)

          return computeDirectly();

     int mid = (low + high) / 2;

     invokeAll (new MyTask (low,mid), new MyTask(mid,high));

}

}

 

Which two changes make the program work correctly?

A.
Results must be retrieved from the newly created MyTask instances and combined.

B.
The threshold value must be increased so that the overhead of task creation does not dominate the cost of computation.

C.
The midpoint computation must be altered so that it splits the workload in an optimal manner.

D.
The compute () method must be changed to return an Integer result.

E.
The compute () method must be enhanced to (fork) newly created tasks.

F.
The myTask class must be modified to extend RecursiveAction instead of RecursiveTask

Risposta A e C

Riferimenti:

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/RecursiveTask.html

 

Q28

Q28

Q27

Given that myFile.txt contains:

First

Second

Third

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

public class ReadFile04 {

     public static void main(String[] args) {

          try (BufferedReader buffIn = new BufferedReader(new FileReader(

                     "D:\\faculty\\myfile.txt"))) {

                String line = "";

                int count = 1;

 

                buffIn.mark(1);

               

                line = buffIn.readLine();

                System.out.println(count + ": " + line);

               

                line = buffIn.readLine();

                count++;

                System.out.println(count + ": " + line);

                buffIn.reset();

               

                line = buffIn.readLine();

                count++;

                System.out.println(count + ": " + line);

 

          } catch (IOException e) {

                System.out.println("IOException");

          }

     }

}

What is the result?

A.
1: First
2: Second
3: Third

B.
1 : First
2: Second
3: First

C.
1: First
2: First
3: First

D.
IOExcepton

E.
Compilation fails

 

Risposta B

readLine() legge una riga di testo dallo stream di ingresso restituendo una stringa.

una riga finisce quando nello stream si incontrano le sequenze "\n",  "\r", oppure "\r\n" e queste sequenze non vengono restituite nella stringa.

Quindi ad ogni readline il programma legge la riga corrente e si posiziona alla riga successiva.

Invece mark consente di mettere un segnalino in un punto dello stream e con il comando reset di tornare al punto marcato.

Quindi il codice esegue queste operazioni:

1)    si marca lo stream in questo punto, cioè all'inizio.

2)    si legge e si stampa la prima riga. Readline ci posiziona alla riga successiva, quindi alla seconda.

3)    si legge e si stampa la riga corrente, quindi la seconda. Readline ci posiziona alla riga successiva, quindi alla terza.

4)    si fa il reset, quindi si ritorna alla marcatura e quindi alla prima riga.

5)    si legge e si stampa la riga corrente, quindi la prima. Readline ci posiziona alla riga successiva, quindi alla seconda ma intanto il programma è arrivato alla fine.

 

Riferimenti:
http://ulibgcj.sourceforge.net/javadoc/java/io/BufferedReader.html

Q26

Given:

public class Print01 {

     public static void main(String[] args) {

          double price = 24.99;

          int quantity = 2;

          String color = "Blue";

          // insert code here. Line ***

     }

}
 

Which two statements, inserted independently at line ***, enable the program to produce the following output:

We have 002 Blue pants that cost $24.99.

A.
System.out.printf(“We have %03d %s pants that cost $%3.2f.\n”,quantity, color, price);

B.
System.out.printf(“We have$03d$s pants that cost $$3.2f.\n”,quantity, color, price);

C.
String out = String.format (“We have %03d %s pants that cost $%3.2f.\n”,quantity, color, price); System.out.println(out);

D.
String out = System.out.format(“We have %03d %s pants that cost $%3.2f.”,quantity, color, price);
System.out.println(out);

E.

System.out.format(“We have %s%spants that cost $%s.\n”,quantity, color, price); 
 

La risposta è A e C

 

A. E’ corretto.

B. No perchè $03d$s e $$3.2f.\n non sono formattate secondo la sintassi e quindi vengono stampate così come sono :

We have$03d$s pants that cost $$3.2f.

C.  E la stesso risultato di A ma usando format invece di printf

D.  No perchè si assegna ad una stringa un PrintStream infatti il codice non compila.

 

E.  E’ tentativo di usare una sintassi minimale ma è errato perché la sintassi %s stampa l'ingresso come una stringa quindi le parole risultano attaccate una all'altra e non viene "paddato" il numero 2 con gli zeri d'avanti.

We have 2Bluepants that cost $24.99.

Q25

Le collezioni in Java non erano in origine tipizzate. Per ovviare a questo problema di robustezza del codice dal Java 5 sono state introdotte le versioni generiche delle collezioni . Per mantenere la retro compatibilità del codice è però sempre possibile in java utilizzare le collezioni non generiche. Dal lato pratico ci sono due API, una per le collezioni generiche e una per quelle non generiche.

 

Sintassi per le collezioni non generiche :

          List  myList = new ArrayList();

          myList.add("stringa");

          myList.add(2);

          String s1 = (String) myList.get(0);

          int s2 = (int) myList.get(0);

La lista  myList non è generica.

Quindi ci possiamo mettere oggetti di tipi diversi (non type-safe), come una String o un int. Quando si recuperano gli oggetti siccome il compilatore non sa di che tipo sono gli oggetti così recuperati vanno castati.

L’ultima riga evidenzia il problema della collezioni non generiche; infatti il compilatore permette di scrivere la linea di codice ma questa a run time provoca una eccezione, infatti stiamo cercando di castare ad intero un elemento che in realtà è una stringa:

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer

      

Sintassi per le collezioni generiche :

          List<String>  myList = new ArrayList();

          myList.add("stringa");

     *    myList.add(2);

          String s1 = myList.get(0);

*    int s2 = (int) myList.get(0);

 

In questo caso il compilatore segnala subito un errore se proviamo ad inserire un elemento intero dentro la collezione generica. Ancora più importante il compilatore segnala un errore se si cerca di recuperare un intero da una collezione di Stringhe. Questo rende il codice più robusto.

 

 

Q24

Given the code fragment:

public class Base {

     BufferedReader br;

     String record;

     public void process() throws FileNotFoundException {

          br = new BufferedReader(new FileReader("manual.txt"));

     }

}

public class Derived extends Base {

     // insert code here. Line ***

     public static void main(String[] args) {

          try {

                new Derived().process();

          } catch (Exception e) {

          }

     }

}

Which code fragment inserted at line ***, enables the code to compile?

A.
       public void process() throws FileNotFoundException, IOException {

             super.process();

             while ((record = br.readLine()) != null) {

                    System.out.println(record);

              }

       }

B.
       public void process() throws IOException {

             super.process();

             while ((record = br.readLine()) != null) {

                    System.out.println(record);

              }

       }

C.
       public void process() throws Exception {

             super.process();

             while ((record = br.readLine()) != null) {

                    System.out.println(record);

              }

       }

D.
       public void process() {

             try {

                    super.process();

                    while ((record = br.readLine()) != null) {

                           System.out.println(record);

                    }

             } catch (IOException | FileNotFoundException e) {

             }

       }

E.
       public void process() {

             try {

                    super.process();

                    while ((record = br.readLine()) != null) {

                           System.out.println(record);

                    }

             } catch (IOException e) {

             }

       }

 

Risposta E

A.

Non compila perché l’eccezione non è compatibile con la classe padre:

Exception IOException is not compatible with throws clause in Base.process()

 

B.

Non compila perché l’eccezione non è compatibile con la classe padre:

Exception IOException is not compatible with throws clause in Base.process()

 

C.

Non compila perché l’eccezione non è compatibile con la classe padre:

Exception Exception is not compatible with throws clause in Base.process()

 

D.

Non compila perché l’eccezione FileNotFoundException estende IOException e quindi non è permesso catturarle entrambe in un blocco multicatch.

The exception FileNotFoundException is already caught by the alternative IOException