Oracle 1Z0-804 Online Practice Questions and Exam Preparation

Oracle 1Z0-804 Online Questions & Answers

• Question 71:

  Which statement creates a low overhead, low-contention random number generator that is isolated to thread to generate a random number between 1 and 100?

  A. int i = ThreadLocalRandom.current().nextInt(1, 101);
  B. int i = ThreadSafeRandom.current().nextInt(1, 101);
  C. int i = (int) Math.random()*100+1;
  D. int i = (int) Math.random(1, 101);
  E. int i = new random().nextInt(100)+1;
  A. int i = ThreadLocalRandom.current().nextInt(1, 101);

  ---

  public class ThreadLocalRandom

  extends Random'

  A random number generator isolated to the current thread. Like the global Random generator used by the Math class, a ThreadLocalRandom is initialized with an internally generated seed that may not otherwise be modified. When

  applicable, use of ThreadLocalRandom rather than shared Random objects in concurrent programs will typically encounter much less overhead and contention. Use of ThreadLocalRandom is particularly appropriate when multiple tasks (for

  example, each a ForkJoinTask) use random numbers in parallel in thread pools.

  Usages of this class should typically be of the form:

  ThreadLocalRandom.current().nextX(...) (where X is Int, Long, etc). When all usages are of this form, it is never possible to accidently share a ThreadLocalRandom across multiple threads.

  This class also provides additional commonly used bounded random generation methods.

  Reference: Class ThreadLocalRandom

• Question 72:

  Given:

  import java.util.regex.Matcher;

  import java.util.regex.Pattern;

  public class Test {

  private static String REGEX = "\\Sto\\S|\\bo\\b";

  private static String INPUT = "Nice to see you,to,be fine.";

  private static String REPLACE =",";

  public static void main(String[] args) {

  Pattern p = Pattern.compile(REGEX);

  Matcher m = p.matcher(INPUT);

  INPUT = m.replaceAll(REPLACE);

  System.out.println(INPUT);

  }

  }

  What is the result?

  A. Nice to see you, be fine
  B. Nice, see you, be fine
  C. Nice, see you, to, be fine
  D. Nice, see you, be fine
  E. Nice to see y, u, be fine
  A. Nice to see you, be fine

  ---

  The text to is removed (replaced by the empty string).

• Question 73:

  Given the fragment:

  public class CustomerApplication {

  public static void main (String args[]) {

  CustomerDAO custDao= new CustomerDAOMemoryImpl(); // Line 3

  // ... other methods

  } }

  Which two valid alternatives to line 3 would decouple this application from a specific implementation of CustomerDAO?

  A. CustomerDAO custDao = CustomerDAO();
  B. CustomerDAO custDao = (CustomerDAO) new Object ();
  C. CustomerDAO custDao = CustomerDAO.getInstance();
  D. CustomerDAO custDao = (CustomerDAO) new CustomerDAOmemoryImp1();
  E. CustomerDAO custDao = customerDAOFactory.getInstance();
  B. CustomerDAO custDao = (CustomerDAO) new Object ();
  E. CustomerDAO custDao = customerDAOFactory.getInstance();

  ---

  Note: In software development, the term "decoupling" is used to identify the separation of software blocks that shouldn't depend on each other. Some building blocks are generic and shouldn't know details of others. Special design techniques

  allow software designers to have as few dependencies as possible. This typically reduces the risk of malfunction in one part of a system when the other part changed. It also forces the developer to focus on one thing at a time.

  Decoupling lowers or minimizes Coupling.

• Question 74:

  Given the code fragment:

  

  What change should you make to apply good coding practices to this fragment?

  A. Add nested try-with-resources statements for the statement and Resulset declarations.
  B. Add the statement and Resulset declarations to the cry-with-resources statement.
  C. Add a finally clause after the catch clause.
  D. Rethrow SQLException.
  C. Add a finally clause after the catch clause.

  ---

  The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling -- it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated.

• Question 75:

  Given:

  import java.util.*;

  public class AccessTest {

  public static void main(String[] args) {

  Thread t1 = new Thread(new WorkerThread());

  Thread t2 = new Thread(new WorkerThread());

  t1.start(); t2.start; // line1

  }

  }

  class WorkPool {

  static ArrayList list = new ArrayList<>(); // line2

  public static void addItem() { // line3

  list.add(1); // Line4

  }

  }

  class WorkerThread implements Runnable {

  static Object bar = new Object ();

  public void run() { //line5

  for (int i=0; i<5000;i++) WorkPool.addItem(); // line6

  }

  }

  Which of the four are valid modifications to synchronize access to the valid list between threads t1 and t2?

  A. Replace line 1 with: Synchronized (t2) (t1.start();) synchronized(t1) (t2.start();)
  B. Replace Line 2 with: static CopyWriteArrayList list = new CopyWriteArrayList();
  C. Replace line 3 with: synchronized public static void addItem () {
  D. Replace line 4 with: synchronized (list) (list.add(1);)
  E. Replace line 5 with: Synchronized public void run () {
  F. replace line 6 with: Synchronized (this) {for (in i = 0, i
  G. Replace line 6 with: synchronized (bar) {for (int i= 0; i
  A. Replace line 1 with: Synchronized (t2) (t1.start();) synchronized(t1) (t2.start();)
  B. Replace Line 2 with: static CopyWriteArrayList list = new CopyWriteArrayList();
  C. Replace line 3 with: synchronized public static void addItem () {
  F. replace line 6 with: Synchronized (this) {for (in i = 0, i

  ---

  B: CopyOnWriteArrayList

  A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.

  This is ordinarily too costly, but may be more efficient than alternatives when traversal operations vastly outnumber mutations, and is useful when you cannot or don't want to synchronize traversals, yet need to preclude interference among concurrent threads. The "snapshot" style iterator method uses a reference to the state of the array at the point that the iterator was created. This array never changes during the lifetime of the iterator, so interference is impossible and the iterator is guaranteed not to throw ConcurrentModificationException

  Note:

  *

  The Java programming language provides two basic synchronization idioms:

  synchronized methods and synchronized statements.

  *

  To make a method synchronized, simply add the synchronized keyword to its declaration:

  Example:

  public class SynchronizedCounter {

  private int c = 0;

  public synchronized void increment() {

  c++;

  }

  }

  *

  A way to create synchronized code is with synchronized statements. Unlike synchronized methods, synchronized statements must specify the object that provides the intrinsic lock: For example:

  public void addName(String name) {

  synchronized(this) {

  lastName = name;

  nameCount++;

  }

  nameList.add(name);

  }

  In this example, the addName method needs to synchronize changes to lastName and nameCount, but also needs to avoid synchronizing invocations of other objects' methods.

  Without synchronized statements, there would have to be a separate, unsynchronized

  method for the sole purpose of invoking nameList.add.

  Reference: The Java Tutorial, Intrinsic Locks and Synchronization

• Question 76:

  Give:

  Class Employee {

  public int checkEmail() {/* . . . */}

  public void sendEmail (String email) {/* . . . */}

  public Boolean validDateEmail(){/* . . . */}

  public void printLetter (String letter) {/* . . . */} }

  Which is correct?

  A. Employee takes advantage of composition.
  B. Employee "has-an" Email.
  C. Employee "is-a" LetterPrinter.
  D. Employee has low cohesion.
  D. Employee has low cohesion.

  ---

  The relationship between Employee and e-mail is poorly implemented here.

  There is low cohesion.

  Note:

  Low cohesion is associated with undesirable traits such as being difficult to maintain, difficult to test, difficult to reuse, and even difficult to understand.

  Cohesion is decreased if:

  The functionalities embedded in a class, accessed through its methods, have little in common.

  Methods carry out many varied activities, often using coarsely-grained or unrelated sets of data.

  Disadvantages of low cohesion (or "weak cohesion") are:

  Increased difficulty in understanding modules.

  Increased difficulty in maintaining a system, because logical changes in the domain affect multiple modules, and because changes in one module require changes in related modules.

  Increased difficulty in reusing a module because most applications won't need the random set of operations provided by a module.

  Reference: Cohesion (computer science)

• Question 77:

  Given:

  public class Task {

  String title;

  static class Counter {

  int counter = 0;

  void increment() {counter++}

  }

  public static void main(String[] args) {

  // insert code here

  }

  }

  Which statement, inserted at line 8, enables the code to compile?

  A. new Task().new Counter().increment();
  B. new Task().Counter().increment();
  C. new Task.Counter().increment();
  D. Task.Counter().increment();
  E. Task.Counter.increment();
  C. new Task.Counter().increment();

• Question 78:

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

  Company

  And the code fragment:

  

  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
  B. Prints only Salesdat, Annual.dat

  ---

  The pattern *dat will match the directory name Salesdat and it will also match the file Annual.dat. It will not be matched to Target.dat which is in a subdirectory.

• Question 79:

  When using the default file system provider with a JVM running on a DOS-based file system, which statement is true?

  A. DOS file attributes can be read as a set in a single method call.
  B. DOS file attributes can be changed as a set in a single method call.
  C. DOS file attributes can be modified for symbolic links and regular files.
  D. DOS file attributes can be modified in the same method that creates the file.
  A. DOS file attributes can be read as a set in a single method call.

  ---

  File attributes associated with a file in a file system that supports legacy "DOS" attributes.

  Usage Example:

  Path file = ...

  DosFileAttributes attrs = Files.readAttributes(file, DosFileAttributes.class);

  Note:

  The method readAttributes() reads a file's attributes as a bulk operation.

• Question 80:

  Which class safely protects the doIt () method from concurrent thread access?

  A. class SafeMethod { Static int ID = 0; Public static void doIt(String s) { Synchronized (s) { System.out.println("Name: " + s + " ID: " + id++); } } }
  B. class SafeMethod { Static int ID = 0; Public static void doIt(String s) { Synchronized (new object () ) { System.out.println("Name: " + s + " ID: " + id++); } } }
  C. class SafeMethod { Static int ID = 0; Public static void doIt(String s) { Synchronized (this) { System.out.println("Name: " + s + " ID: " + id++); } } }
  D. class SafeMethod { Static int ID = 0; Public static void doIt(String s) { Synchronized (SafeMethod.class) { System.out.println("Name: " + s + " ID: " + id++); } } }
  C. class SafeMethod { Static int ID = 0; Public static void doIt(String s) { Synchronized (this) { System.out.println("Name: " + s + " ID: " + id++); } } }

  ---

  It should be pointed out that:

  public void blah() {

  synchronized (this) {

  // do stuff

  }

  }

  is semantically equivalent to:

  public synchronized void blah() {

  // do stuff

  }

  Incorrect answer:

  B: A constructor cannot be synchronized.