Oracle 1Z1-805 real exam prep : Upgrade to Java SE 7 Programmer

Given:
class Fibonacci extends RecursiveTask<Integer> {
final int n;
Fibonacci (int n) { this.n = n }
Integer compute () {
if (n <= 1)
return n;
Fibonacci f1 = new Fibonacci (n - 1);
f1.fork; // Line X
Fibonacci f2 = new Fibonacci (n - 2); // Line Y
return f2.compute() + f1.join;
}
}
Suppose that lines X and Y are transposed:
Fibonacci f2 = new Fibonacci (n - 2); // Line Y
f1.fork; // Line X
What is the likely result?

• A. The program produces an incorrect result
• B. The program produces the correct result, the better performance than the original.
• C. The program produces the correct result, with performance degraded to the equivalent of being single-threaded.
• D. An exception is thrown at runtime
• E. The program produces the correct result, with similar performance to the original
• F. The program goes into an infinite loop

Given the following code fragment:
public static void getInfo() {
//insert code here
List fontCatalog = new ArrayList();
fontCatalog.add("Algerian");
fontCatalog.add("Cambria");
fontCatalog.add("Lucida Bright");
category.put("firstCategory",fontCatalog);
List entrySet = new ArrayList(category.entrySet());
Iterator it = entrySet.iterator();
while(it.hasNext()) {
System.out.println(it.next));
}
}
Which two code fragments, when inserted independently at line **, enable the code to compile?

• A. Map<String, List<String>> category = new HashMap<List> ();
• B. Map<String, List<String>> category = new HashMap <String, ArrayList<String>> ();
• C. Map<String, List<String>> category = new HashMap<String, List <>> ();
• D. Map<String, List<String>> category = new HashMap<> ();
• E. Map<String, List<String>> category = new HashMap<String, List<String>> ();
• F. Map<String, List<String>> category = new HashMap<<>,List<>>();

Given the following code fragment:
public class Calc {
public static void main (String [] args) {
//* insert code here Line ** System.out.print("The decimal value is" + var);
}
}
Which three code fragments, when inserted independently at line **, enable the code to compile/

• A. double var = 0b10_01D;
• B. double var = 0b10_01;
• C. int var = 0b_1001;
• D. long var = 0b100_01L;
• E. float var = 0b10_01;
• F. float var = 0b10_01F;

Consider the following database table: Inventory Table
*Item_ID, Integer: PK
*Item_name, Varchar (20)
*Price, Numeric (10, 2)
*Quan, Integer
Consider the following method that updates the prices in the Inventory table:
public static void updatePrices{ // #1: missing line
Connection con) throws SQLException {
// #2: missing line
PreparedStatement updatePrices = con.prepareStatement (updatePricesString);
// #3: missing line { // #4: missing line updatePrices.executeUpdate(); } }
This method us missing four lines, which group of lines complete this method?

• A. 1. HashMap<Integer> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? Where item_id '?' ";
  3.For (Integer x: newPrice)
  4.updatePrice.setInt(1, x);
• B. 1. HashMap<Integer, Float> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? Where item_id '?' ";
  3.For (map.Entry<Integer, String> x : newPrices.entrySet())
  4.UpdatePrices.setInt(1, x.getvalue().floatValue()); updatePrice.setString (2, x.getvalue());
• C. 1. HashMap<Integer, String> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? Where item_id '?' ";
  3.For (map.Entry<Integer, String> x : newPrices.entrySet())
  4.UpdatePrices,setString(1, x.getKey()); updatePrices.setFloat(2, x.getValue().floatValue());
• D. 1. HashMap<Integer, String> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? WHERE item_name '?' ";
  3.For (map.Entry<Integer, String> x : newPrices.entrySet())
  4.UpdatePrices.setFloat(1, x.getvalue().floatValue()); updatePrice.setString (2, x.getKey());
• E. 1. HashMap<Integer, Float> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? WHERE item_id '?' ";
  3.For (map.Entry<Integer, String> x : newPrices.entrySet())
  4.UpdatePrices.setFloat(1, x.getvalue().floatValue()); updatePrice.setString (2,
  x.getKey().intValue());
• F. 1. HashMap<Integer, Float> newPrices,
  2.StringupdatePriceString = "UPDATE inventory SET price =? Where item_id '?' ";
  3.For (map.Entry<Integer, String> x : newPrices.entrySet())
  4.UpdatePrices.setInt(1, x.getvalue().floatValue()); updatePrice.setString (2, x.getvalue().floatValue()

The advantage of a CallableStatement over a PreparedStatement is that it:

• A. Supports transactions
• B. Runs on the database
• C. Uses Java instead of native SQL
• D. Is easier to construct