Showing posts with label Online Guidance. Show all posts
Showing posts with label Online Guidance. Show all posts

Friday, August 24, 2012

Exercise -7 (Collections and Generics)



1. Given: 
public static void main(String[] args) {
// INSERT DECLARATION HERE
for (int i = 0; i <= 10; i++) {
List<Integer> row = new ArrayList<Integer>();
for (int j = 0; j <= 10; j++)
row.add(i * j);
table.add(row);
}
for (List<Integer> row : table)
System.out.println(row);
}
Which statements could be inserted at // INSERT DECLARATION HERE to allow this code to compile and run? (Choose all that apply.)
A. List<List<Integer>> table = new List<List<Integer>>();
B. List<List<Integer>> table = new ArrayList<List<Integer>>();
C. List<List<Integer>> table = new ArrayList<ArrayList<Integer>>();
D. List<List, Integer> table = new List<List, Integer>();
E. List<List, Integer> table = new ArrayList<List, Integer>();
F. List<List, Integer> table = new ArrayList<ArrayList, Integer>();
G. None of the above
Answer:
B is correct.
A is incorrect because List is an interface, so you can't say new List() regardless of any generic types. D, E, and F are incorrect because List only takes one type parameter (a Map would take two, not a List). C is tempting, but incorrect. The type argument <List<Integer>> must be the same for both sides of the assignment, even though the constructor new ArrayList() on the right side is a subtype of the declared type List on the left. (Objective 6.4)

2. Which statements are true about comparing two instances of the same class, given that the equals() and hashCode() methods have been properly overridden? (Choose all that apply.)
A. If the equals() method returns true, the hashCode() comparison == might return false
B. If the equals() method returns false, the hashCode() comparison == might return true
C. If the hashCode() comparison == returns true, the equals() method must return true
D. If the hashCode() comparison == returns true, the equals() method might return true
E. If the hashCode() comparison != returns true, the equals() method might return true
Answer:
B and D. B is true because often two dissimilar objects can return the same hashcode value. D is true because if the hashCode() comparison returns ==, the two objects might or might not be equal.
A, C, and E are incorrect. C is incorrect because the hashCode() method is very flexible in its return values, and often two dissimilar objects can return the same hash code value. A and E are a negation of the hashCode() and equals() contract. (Objective 6.2)

3. Given: 
public static void before() {
Set set = new TreeSet();
set.add("2");
set.add(3);
set.add("1");
Iterator it = set.iterator();
while (it.hasNext())
System.out.print(it.next() + " ");
}
Which statements are true?
A. The before() method will print 1 2
B. The before() method will print 1 2 3
C. The before() method will print three numbers, but the order cannot be determined
D. The before() method will not compile
E. The before() method will throw an exception at runtime
Answer:
E is correct. You can't put both Strings and ints into the same TreeSet. Without generics, the compiler has no way of knowing what type is appropriate for this TreeSet, so it allows everything to compile. At runtime, the TreeSet will try to sort the elements as they're added, and when it tries to compare an Integer with a String it will throw a ClassCastException. Note that although the before() method does not use generics, it does use autoboxing. Watch out for code that uses some new features and some old features mixed together.
A, B, C, and D are incorrect based on the above. (Objective 6.5)

4. Given: 
import java.util.*;
class MapEQ {
public static void main(String[] args) {
Map<ToDos, String> m = new HashMap<ToDos, String>();
ToDos t1 = new ToDos("Monday");
ToDos t2 = new ToDos("Monday");
ToDos t3 = new ToDos("Tuesday");
m.put(t1, "doLaundry");
m.put(t2, "payBills");
m.put(t3, "cleanAttic");
System.out.println(m.size());
} }
class ToDos{
String day;
ToDos(String d) { day = d; }
public boolean equals(Object o) {
return ((ToDos)o).day == this.day;
}
// public int hashCode() { return 9; }
}
Which is correct? (Choose all that apply.)
A. As the code stands it will not compile
B. As the code stands the output will be 2
C. As the code stands the output will be 3
D. If the hashCode() method is uncommented the output will be 2
E. If the hashCode() method is uncommented the output will be 3
F. If the hashCode() method is uncommented the code will not compile
Answer:
C and D are correct. If hashCode() is not overridden then every entry will go into its own bucket, and the overridden equals() method will have no effect on determining equivalency. If hashCode() is overridden, then the overridden equals() method will view t1 and t2 as duplicates.
A, B, E, and F are incorrect based on the above. (Objective 6.2)

5. Given: 
public class AccountManager {
private Map accountTotals = new HashMap(); //line 13
private int retirementFund;

public int getBalance(String accountName) {
Integer total = (Integer) accountTotals.get(accountName);  // line 17
if (total == null)
total = Integer.valueOf(0);
return total.intValue();   // line 20
}
public void setBalance(String accountName, int amount) {
accountTotals.put(accountName, Integer.valueOf(amount)); // line 24
} }
This class is to be updated to make use of appropriate generic types, with no changes in behavior (for better or worse). Which of these steps could be performed? (Choose three.)
A. Replace line 13 with private
Map<String, int> accountTotals = new HashMap<String, int>();
B. Replace line 13 with private
Map<String, Integer> accountTotals = new HashMap<String, Integer>();
C. Replace line 13 with
private Map<String<Integer>> accountTotals = new HashMap<String<Integer>>();
D. Replace lines 17-20 with
int total = accountTotals.get(accountName);
if (total == null) total = 0;
return total;
E. Replace lines 17-20 with
Integer total = accountTotals.get(accountName);
if (total == null) total = 0; return total;
F. Replace lines 17-20 with return accountTotals.get(accountName);
G. Replace line 24 with accountTotals.put(accountName, amount);
H. Replace line 24 with accountTotals.put(accountName, amount.intValue());
Answer:
B, E, and G are correct.
A is wrong because you can't use a primitive type as a type parameter. C is wrong because a Map takes two type parameters separated by a comma. D is wrong because an int can't autobox to a null, and F is wrong because a null can't unbox to 0. H is wrong because you can't autobox a primitive just by trying to invoke a method with it. (Objective 6.4)

6. Given: 
interface Hungry<E> { void munch(E x); }
interface Carnivore<E extends Animal> extends Hungry<E> {}
interface Herbivore<E extends Plant> extends Hungry<E> {}
abstract class Plant {}
class Grass extends Plant {}
abstract class Animal {}
class Sheep extends Animal implements Herbivore<Sheep> {
public void munch(Sheep x) {}
}
class Wolf extends Animal implements Carnivore<Sheep> {
public void munch(Sheep x) {}
}
Which of the following changes (taken separately) would allow this code to compile? (Choose all that apply.)
A. Change the Carnivore interface to
interface Carnivore<E extends Plant> extends Hungry<E> {}
B. Change the Herbivore interface to
interface Herbivore<E extends Animal> extends Hungry<E> {}
C. Change the Sheep class to
class Sheep extends Animal implements Herbivore<Plant> {
public void munch(Grass x) {}
}
D. Change the Sheep class to
class Sheep extends Plant implements Carnivore<Wolf> {
public void munch(Wolf x) {}
}
E. Change the Wolf class to
class Wolf extends Animal implements Herbivore<Grass> {
public void munch(Grass x) {}
}
F. No changes are necessary

Answer:
B is correct. The problem with the original code is that Sheep tries to implement HerbivoresSheep> and Herbivore declares that its type parameter E can be any type that extends Plant. Since a Sheep is not a Plant, Herbivore<Sheep> makes no sense- the type Sheep is outside the allowed range of Herbivore's parameter E. Only solutions that either alter the definition of a Sheep or alter the definition of Herbivore will be able to fix this. So A, E, and F are eliminated. B works, changing the definition of an Herbivore to allow it to eat Sheep solves the problem. C doesn't work because an Herbivore<Plant> must have a munch(Plant) method, not munch(Grass). And D doesn't work, because in D we made Sheep extend Plant, now the Wolf class breaks because its munch(Sheep) method no longer fulfills the contract of Carnivore. (Objective 6.4)

7. Which collection class(es) allows you to grow or shrink its size and provides indexed access to its elements, but whose methods are not synchronized? (Choose all that apply.)
A. java.util.HashSet
B. java.util.LinkedHashSet
C. java.util.List
D. java.util.ArrayList
E. java.util.Vector
F. java.util.PriorityQueue
Answer:
D is correct. All of the collection classes allow you to grow or shrink the size of your collection. ArrayList provides an index to its elements. The newer collection classes tend not to have synchronized methods. Vector is an older implementation of ArrayList functionality and has synchronized methods; it is slower than ArrayList.
A, B, C, E, and F are incorrect based on the logic described above; Notes: C, List is an interface, and F, PriorityQueue does not offer access by index. (Objective 6.1)

8. Given a method declared as 
public static <E extends Number> List<E> process(List<E> nums)
A programmer wants to use this method like this 
// INSERT DECLARATIONS HERE
output = process(input);
Which pairs of declarations could be placed at // INSERT DECLARATIONS HERE to allow the code to compile? (Choose all that apply.)
A. ArrayList<Integer> input = null; ArrayList<Integer> output = null;
B. ArrayList<Integer> input = null; List<Integer> output = null;
C. ArrayList<Integer> input = null; List<Number> output = null;
D. List<Number> input = null; ArrayList<Integer> output = null;
E. List<Number> input = null; List<Number> output = null;
F. List<Integer> input = null; List<Integer> output = null;
G. None of the above
Answer:
B, E, and F are correct.
The return type of process is definitely declared as a List, not an ArrayList, so A and D are wrong. C is wrong because the return type evaluates to List<Integer>, and that can't be assigned to a variable of type List<Number>. Of course all these would probably cause a NullPointerException since the variables are still null-but the question only asked us to get the code to compile. (Objective 6.4)

9. Given the proper import statement(s), and 
PriorityQueue<String> pq = new PriorityQueue<String>();
pq.add("2");
pq.add("4");
System.out.print(pq.peek() + " ");
pq.offer("1");
pq.add("3");
pq.remove("1");
System.out.print(pq.poll() + " ");
if(pq.remove("2")) System.out.print(pq.poll() + " ");
System.out.println(pq.poll() + " " + pq.peek());
What is the result?
A. 2 2 3 3
B. 2 2 3 4
C. 4 3 3 4
D. 2 2 3 3 3
E. 4 3 3 3 3
F. 2 2 3 3 4
G. Compilation fails
H. An exception is thrown at runtime
Answer:
B is correct. For the sake of the exam, add() and offer() both add to (in this case), naturally sorted queues. The calls to poll() both return and then remove the first item from the queue, so the if test fails.
A, C, D, E, F, G, and H are incorrect based on the above. (Objective 6.1)

10. Given: 
import java.util.*;
public class Mixup {
public static void main(String[] args) {
Object o = new Object();
// insert code here   line 7
s.add("o");
s.add(o);
}
}
And these three fragments:
I. Set s = new HashSet();
II. TreeSet s = new TreeSet();
III. LinkedHashSet s = new LinkedHashSet();
When fragments I, II, or III are inserted, independently, at line 7, which are true? (Choose all that apply.)
A. Fragment I compiles
B. Fragment II compiles
C. Fragment III compiles
D. Fragment I executes without exception
E. Fragment II executes without exception
F. Fragment III executes without exception
Answer:
A, B, C, D, and F are all correct.
Only E is incorrect. Elements of a TreeSet must in some way implement Comparable. (Objective 6.1)

11. Given: 
import java.util.*;
class Turtle {
int size;
public Turtle(int s) { size = s; }
public boolean equals(Object o) { return (this.size == ((Turtle)o).size); }
// insert code here line 8
}
public class TurtleTest {
public static void main(String[] args) {
LinkedHashSet<Turtle> t = new LinkedHashSet<Turtle>();
t.add(new Turtle(1)); t.add(new Turtle(2)); t.add(new Turtle(1));
System.out.println(t.size());
}
}
And these two fragments:
I. public int hashCode() { return size/5; }
II. // no hashCode method declared
If fragment I or II is inserted, independently, at line 8, which are true? (Choose all that apply.)
A. If fragment I is inserted, the output is 2
B. If fragment I is inserted, the output is 3
C. If fragment II is inserted, the output is 2
D. If fragment II is inserted, the output is 3
E. If fragment I is inserted, compilation fails
F. If fragment II is inserted, compilation fails
Answer:
A and D are correct. While fragment II wouldn't fulfill the hashCode() contract (as you can see by the results), it is legal Java. For the purpose of the exam, if you don't override hashCode(), every object will have a unique hashcode.
B, C, E, and F are incorrect based on the above. (Objective 6.2)

12. Given the proper import statement(s), and: 
TreeSet<String> s = new TreeSet<String>();
 TreeSet<String> subs = new TreeSet<String>();
s.add("a"); s.add("b"); s.add("c"); s.add("d"); s.add("e");

subs = (TreeSet)s.subSet("b", true, "d", true);
s.add("g");
s.pollFirst();
s.pollFirst();
s.add("c2");
System.out.println(s.size() +" "+ subs.size());
Which are true? (Choose all that apply.)
A. The size of s is 4
B. The size of s is 5
C. The size of s is 7
D. The size of subs is 1
E. The size of subs is 2
F. The size of subs is 3
G. The size of subs is 4
H. An exception is thrown at runtime
Answer:
B and F are correct. After "g" is added, TreeSet s contains six elements and TreeSet subs contains three (b, c, d), because "g" is out of the range of subs. The first pollFirst() finds and removes only the "a". The second pollFirst() finds and removes the "b" from both TreeSets (remember they are backed). The final add() is in range of both TreeSets. The final contents are [c,c2,d,e,g] and [c,c2,d].
A, C, D, E, G, and H are incorrect based on the above. (Objective 6.3)

13. Given: 
import java.util.*;
public class Magellan {
public static void main(String[] args) {
TreeMap<String, String> myMap = new TreeMap<String, String>();
myMap.put("a", "apple"); myMap.put("d", "date");
myMap.put("f", "fig"); myMap.put("p", "pear");
System.out.println("1st after mango: " + // sop 1
myMap.higherKey("f"));
System.out.println("1st after mango: " + // sop 2
myMap.ceilingKey("f"));
System.out.println("1st after mango: " + // sop 3
myMap.floorKey("f"));
SortedMap<String, String> sub = new TreeMap<String, String>();
sub = myMap.tailMap("f");
System.out.println("1st after mango: " + // sop 4
sub.firstKey());
}
}
Which of the System.out.println statements will produce the output 1st after mango: p? (Choose all that apply.)
A. sop 1
B. sop 2
C. sop 3
D. sop 4
E. None; compilation fails
F. None; an exception is thrown at runtime
Answer:
A is correct. The ceilingKey() method's argument is inclusive. The floorKey() method would be used to find keys before the specified key. The firstKey() method's argument is also inclusive.
B, C, D, E, and F are incorrect based on the above. (Objective 6.3)

14. Given: 
import java.util.*;
class Business { }
class Hotel extends Business { }
class Inn extends Hotel { }
public class Travel {
ArrayList<Hotel> go() {
// insert code here  line 9
}
}
Which, inserted independently at line 9, will compile? (Choose all that apply.)
A. return new ArrayList<Inn>();
B. return new ArrayList<Hotel>();
C. return new ArrayList<Object>();
D. return new ArrayList<Business>();
Answer:
B is correct.
A is incorrect because polymorphic assignments don't apply to generic type parameters. C and D are incorrect because they don't follow basic polymorphism rules. (Objective 6.4)

15. Given: 
import java.util.*;
class Dog { int size; Dog(int s) { size = s; } }
public class FirstGrade {
public static void main(String[] args) {
TreeSet<Integer> i = new TreeSet<Integer>();
TreeSet<Dog> d = new TreeSet<Dog>();
d.add(new Dog(1)); d.add(new Dog(2)); d.add(new Dog(1));
i.add(1); i.add(2); i.add(1);
System.out.println(d.size() + " " + i.size());
}
}
What is the result?
A. 1 2
B. 2 2
C. 2 3
D. 3 2
E. 3 3
F. Compilation fails
G. An exception is thrown at runtime
Answer:
G is correct. Class Dog needs to implement Comparable in order for a TreeSet (which keeps its elements sorted) to be able to contain Dog objects.
A, B, C, D, E, and F are incorrect based on the above. (Objective 6.5)

16. Given: 
import java.util.*;
public class GeoCache {
public static void main(String[] args) {
String[] s = {"map", "pen", "marble", "key"};
Othello o = new Othello();
Arrays.sort(s,o);
for(String s2: s) System.out.print(s2 + " ");
System.out.println(Arrays.binarySearch(s, "map"));
}
static class Othello implements Comparator<String> {
public int compare(String a, String b) { return b.compareTo(a); }
}
}
Which are true? (Choose all that apply.)
A. Compilation fails
B. The output will contain a 1
C. The output will contain a 2
D. The output will contain a -1
E. An exception is thrown at runtime
F. The output will contain "key map marble pen"
G. The output will contain "pen marble map key"
Answer:
D and G are correct. First, the compareTo() method will reverse the normal sort. Second, the sort() is valid. Third, the binarySearch() gives -1 because it needs to be invoked using the same Comparator (o), as was used to sort the array. Note that when the binarySearch() returns an "undefined result" it doesn't officially have to be a -1, but it usually is, so if you selected only G, you get full credit!
A, B, C, E, and F are incorrect based on the above. (Objective 6.5)


regards,
Agni..
Executive,
Talent Sprint
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses
Posted by at No comments:
Labels: , , , , , ,

Friday, August 17, 2012

Exercise- 6 (Strings)



1. Given: 
import java.util.regex.*;
class Regex2 {
public static void main(String[] args) {
Pattern p = Pattern.compile(args[0]);
Matcher m = p.matcher(args[1]);
boolean b = false;
while(b = m.find()) {
System.out.print(m.start() + m.group());
}
}
}
And the command line:
java Regex2 "\d*" ab34ef
What is the result?
A. 234
B. 334
C. 2334
D. 0123456
E. 01234456
F. 12334567
G. Compilation fails
Answer:
E is correct. The \d is looking for digits. The * is a quantifier that looks for 0 to many occurrences of the pattern that precedes it. Because we specified *, the group() method returns empty Strings until consecutive digits are found, so the only time group() returns a value is when it returns 34 when the matcher finds digits starting in position 2. The start() method returns the starting position of the previous match because, again, we said find 0 to many occurrences.
A, B, C, D, F, and G are incorrect based on the above. (Objective 3.5)

2. Given: 
import java.io.*;
class Player {
Player() { System.out.print("p"); }
}
class CardPlayer extends Player implements Serializable {
CardPlayer() { System.out.print("c"); }
public static void main(String[] args) {
CardPlayer c1 = new CardPlayer();
try {
FileOutputStream fos = new FileOutputStream("play.txt");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(c1);
os.close();
FileInputStream fis = new FileInputStream("play.txt");
ObjectInputStream is = new ObjectInputStream(fis);
CardPlayer c2 = (CardPlayer) is.readObject();
is.close();
} catch (Exception x ) { }
}
}
What is the result?
A. pc
B. pcc
C. pcp
D. pcpc
E. Compilation fails
F. An exception is thrown at runtime
Answer:
C is correct. It's okay for a class to implement Serializable even if its superclass doesn't. However, when you deserialize such an object, the non-serializable superclass must run its constructor. Remember, constructors don't run on deserialized classes that implement Serializable.
A, B, D, E, and F are incorrect based on the above. (Objective 3.3)

3. Given: 
class TKO {
public static void main(String[] args) {
String s = "-";
Integer x = 343;
long L343 = 343L;
if(x.equals(L343)) s += ".e1 ";
if(x.equals(343)) s += ".e2 ";
Short s1 = (short)((new Short((short)343)) / (new Short((short)49)));
if(s1 == 7) s += "=s ";
if(s1 < new Integer(7+1)) s += "fly ";
System.out.println(s);
} }
Which of the following will be included in the output String s? (Choose all that apply.)
A. .e1
B. .e2
C. =s
D. fly
E. None of the above
F. Compilation fails
G. An exception is thrown at runtime
Answer:
B, C, and D are correct. Remember, that the equals() method for the integer wrappers will only return true if the two primitive types and the two values are equal. With C, it's okay to unbox and use ==. For D, it's okay to create a wrapper object with an expression, and unbox it for comparison with a primitive.
A, E, F, and G are incorrect based on the above. (Remember that A is using the equals() method to try to compare two different types.) (Objective 3.1)

4. Given: 
import java.io.*;
class Keyboard { }
public class Computer implements Serializable {
	
		private Keyboard k = new Keyboard();
public static void main(String[] args) {
Computer c = new Computer();
c.storeIt(c);
}
void storeIt(Computer c) {
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("myFile"));
os.writeObject(c);
os.close();
System.out.println("done");
} catch (Exception x) {System.out.println("exc"); }
}
}
What is the result? (Choose all that apply.)
A. exc
B. done
C. Compilation fails
D. Exactly one object is serialized
E. Exactly two objects are serialized
Answer:
A is correct. An instance of type Computer Has-a Keyboard. Because Keyboard doesn't implement Serializable, any attempt to serialize an instance of Computer will cause an exception to be thrown.
B, C, D, and E are incorrect based on the above. If Keyboard did implement Serializable then two objects would have been serialized. (Objective 3.3)

5. Using the fewest fragments possible (and filling the fewest slots possible), complete the code below so that the class builds a directory named "dir3" and creates a file named "file3" inside "dir3". Note you can use each fragment either zero or one times. Code: 
import java.io.______________
class Maker {
public static void main(String[] args) {
___________ ___________ ___________
___________ ___________ ___________
___________ ___________ ___________
___________ ___________ ___________
___________ ___________ ___________
___________ ___________ ___________
___________ ___________ ___________
} }
Fragments:
File; FileDescriptor; FileWriter; Directory;
try { .createNewDir(); File dir File
{ } (Exception x) ("dir3"); file
file .createNewFile(); = new File = new File
dir (dir, "file3"); (dir, file); .createFile();
} catch ("dir3", "file3"); .mkdir(); File file

Answer: 
import java.io.File;
class Maker {
public static void main(String[] args) {
try {
File dir = new File("dir3");
dir.mkdir();
File file = new File(dir, "file3");
file.createNewFile();
} catch (Exception x) { }
} }

Notes: The new File statements don't make actual files or directories, just objects. You need the mkdir() and createNewFile() methods to actually create the directory and the file. (Objective 3.2)

6. Given that 1119280000000L is roughly the number of milliseconds from Jan. 1, 1970, to June 20, 2005, and that you want to print that date in German, using the LONG style such that "June" will be displayed as "Juni", complete the code using the fragments below. Note: you can use each fragment either zero or one times, and you might not need to fill all of the slots. Code: 
import java.___________
import java.___________
class DateTwo {
public static void main(String[] args) {
Date d = new Date(1119280000000L);
DateFormat df = ___________________________
________________ , _________________ );
System.out.println(________________
}
}
Fragments:
io.*; new DateFormat( Locale.LONG
nio.*; DateFormat.getInstance( Locale.GERMANY
util.*; DateFormat.getDateInstance( DateFormat.LONG
text.*; util.regex; DateFormat.GERMANY
date.*; df.format(d)); d.format(df));

Answer:
import java.util.*; import java.text.*; class DateTwo { public static void main(String[] args) { Date d = new Date(1119280000000L); DateFormat df = DateFormat.getDateInstance( DateFormat.LONG, Locale.GERMANY); System.out.println(df.format(d)); } } Notes: Remember that you must build DateFormat objects using static methods. Also remember that you must specify a Locale for a DateFormat object at the time of instantiation. The getInstance() method does not take a Locale. (Objective 3.4)

7. Given: 
import java.io.*;
class Directories {
static String [] dirs = {"dir1", "dir2"};
public static void main(String [] args) {
for (String d : dirs) {
// insert code 1 here
File file = new File(path, args[0]);
// insert code 2 here
}
}
}
and that the invocation
java Directories file2.txt
is issued from a directory that has two subdirectories, "dir1" and "dir2", and that "dir1" has a file "file1.txt" and "dir2" has a file "file2.txt", and the output is "false true", which set(s) of code fragments must be inserted? (Choose all that apply.)
A. String path = d; System.out.print(file.exists() + " ");
B. String path = d; System.out.print(file.isFile() + " ");
C. String path = File.separator + d; System.out.print(file.exists() + " ");
D. String path = File.separator + d; System.out.print(file.isFile() + " ");
Answer:
A and B are correct. Because you are invoking the program from the directory whose direct subdirectories are to be searched, you don't start your path with a File.separator character. The exists() method tests for either files or directories; the isFile() method tests only for files. Since we're looking for a file, both methods work.
C and D are incorrect based on the above. (Objective 3.2)

8. Given: 
import java.io.*;
public class TestSer {
public static void main(String[] args) {
SpecialSerial s = new SpecialSerial();
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("myFile"));
os.writeObject(s); os.close();
System.out.print(++s.z + " ");
ObjectInputStream is = new ObjectInputStream(
new FileInputStream("myFile"));
SpecialSerial s2 = (SpecialSerial)is.readObject();
is.close();
System.out.println(s2.y + " " + s2.z);
} catch (Exception x) {System.out.println("exc"); }
}
}
class SpecialSerial implements Serializable {
transient int y = 7;
static int z = 9;
}
Which are true? (Choose all that apply.)
A. Compilation fails
B. The output is 10 0 9
C. The output is 10 0 10
D. The output is 10 7 9
E. The output is 10 7 10
F. In order to alter the standard deserialization process you would implement the readObject() method in SpecialSerial
G. In order to alter the standard deserialization process you would implement the defaultReadObject() method in SpecialSerial
Answer:
C and F are correct. C is correct because static and transient variables are not serialized when an object is serialized. F is a valid statement.
A, B, D, and E are incorrect based on the above. G is incorrect because you don't implement the defaultReadObject() method, you call it from within the readObject()method, along with any custom read operations your class needs. (Objective 3.3)

9. Given: 
3. public class Theory {
4. public static void main(String[] args) {
5. String s1 = "abc";
6. String s2 = s1;
7. s1 += "d";
8. System.out.println(s1 + " " + s2 + " " + (s1==s2));
9.
10. StringBuffer sb1 = new StringBuffer("abc");
11. StringBuffer sb2 = sb1;
12. sb1.append("d");
13. System.out.println(sb1 + " " + sb2 + " " + (sb1==sb2));
14. }
15. }
Which are true? (Choose all that apply.)
A. Compilation fails
B. The first line of output is abc abc true
C. The first line of output is abc abc false
D. The first line of output is abcd abc false
E. The second line of output is abcd abc false
F. The second line of output is abcd abcd true
G. The second line of output is abcd abcd false
Answer:
D and F are correct. While String objects are immutable, references to Strings are mutable. The code s1 += "d"; creates a new String object. StringBuffer objects are mutable, so the append() is changing the single StringBuffer object to which both StringBuffer references refer.
A, B, C, E, and G are incorrect based on the above. (Objective 3.1)

10. Given: 
3. import java.io.*;
4. public class ReadingFor {
5. public static void main(String[] args) {
6. String s;
7. try {
8. FileReader fr = new FileReader("myfile.txt");
9. BufferedReader br = new BufferedReader(fr);
10. while((s = br.readLine()) != null)
11. System.out.println(s);
12. br.flush();
13. } catch (IOException e) { System.out.println("io error"); }
16. }
17. }
And given that myfile.txt contains the following two lines of data:
ab cd
What is the result?
A. ab
B. abcd
C. ab cd
D. a b c d
E. Compilation fails
Answer:
E is correct. You need to call flush() only when you're writing data. Readers don't have flush() methods. If not for the call to flush(), answer C would be correct.
A, B, C, and D are incorrect based on the above. (Objective 3.2)

11. Given: 
3. import java.io.*;
4. public class Talker {
5. public static void main(String[] args) {
6. Console c = System.console();
7. String u = c.readLine("%s", "username: ");
8. System.out.println("hello " + u);
9. String pw;
10. if(c != null && (pw = c.readPassword("%s", "password: ")) != null)
11. // check for valid password
12. }
13. }
If line 6 creates a valid Console object, and if the user enters fred as a username and 1234 as a password, what is the result? (Choose all that apply.)
A.
username:
password:
B.
username: fred
password:
C.
username: fred
password: 1234
D. Compilation fails
E. An exception is thrown at runtime
Answer:
D is correct. The readPassword() method returns a char[]. If a char[] were used, answer B would be correct.
A, B, C, and E are incorrect based on the above. (Objective 3.2)

12. Given: 
3. import java.io.*;
4. class Vehicle { }
5. class Wheels { }
6. class Car extends Vehicle implements Serializable { }
7. class Ford extends Car { }
8. class Dodge extends Car {
9. Wheels w = new Wheels();
10. }
Instances of which class(es) can be serialized? (Choose all that apply.)
A. Car
B. Ford
C. Dodge
D. Wheels
E. Vehicle
Answer:
A and B are correct. Dodge instances cannot be serialized because they "have" an instance of Wheels, which is not serializable. Vehicle instances cannot be serialized even though the subclass Car can be.
C, D, and E are incorrect based on the above. (Objective 3.3)

13. Given: 
3. import java.text.*;
4. public class Slice {
5. public static void main(String[] args) {
6. String s = "987.123456";
7. double d = 987.123456d;
8. NumberFormat nf = NumberFormat.getInstance();
9. nf.setMaximumFractionDigits(5);
10. System.out.println(nf.format(d) + " ");
11. try {
12. System.out.println(nf.parse(s));
13. } catch (Exception e) { System.out.println("got exc"); }
14. }
15. }
Which are true? (Choose all that apply.)
A. The output is 987.12345 987.12345
B. The output is 987.12346 987.12345
C. The output is 987.12345 987.123456
D. The output is 987.12346 987.123456
E. The try/catch block is unnecessary
F. The code compiles and runs without exception
G. The invocation of parse() must be placed within a try/catch block
Answer:
D, F, and G are correct. The setMaximumFractionDigits() applies to the formatting but not the parsing. The try/catch block is placed appropriately. This one might scare you into thinking that you'll need to memorize more than you really do. If you can remember that you're formatting the number and parsing the string you should be fine for the exam.
A, B, C, and E are incorrect based on the above. (Objective 3.4)

14. Given: 
3. import java.util.regex.*;
4. public class Archie {
5. public static void main(String[] args) {
6. Pattern p = Pattern.compile(args[0]);
7. Matcher m = p.matcher(args[1]);
8. int count = 0;
9. while(m.find())
10. count++;
11. System.out.print(count);
12. }
13. }
And given the command line invocation:
java Archie "\d+" ab2c4d67
What is the result?
A. 0
B. 3
C. 4
D. 8
E. 9
F. Compilation fails
Answer:
B is correct. The "\d" metacharacter looks for digits, and the + quantifier says look for "one or more" occurrences. The find() method will find three sets of one or more consecutive digits: 2, 4, and 67.
A, C, D, E, and F are incorrect based on the above. (Objective 3.5)

15. Given: 
import java.util.*;
public class Looking {
public static void main(String[] args) {
String input = "1 2 a 3 45 6";
Scanner sc = new Scanner(input);
int x = 0;
do {
x = sc.nextInt();
System.out.print(x + " ");
} while (x!=0);
}
}
What is the result?
A. 1 2
B. 1 2 3 45 6
C. 1 2 3 4 5 6
D. 1 2 a 3 45 6
E. Compilation fails
F. 1 2 followed by an exception
Answer:
F is correct. The nextXxx() methods are typically invoked after a call to a hasNextXxx(), which determines whether the next token is of the correct type.
A, B, C, D, and E are incorrect based on the above. (Objective 3.5)


.


regards,
Agni..
Executive
Talent Sprint.
Hyderabad.


for Feedback and Support simply drop a mail in
agnbi2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses
Posted by at No comments:
Labels: , , , ,

Monday, August 13, 2012

String Handling



Using String, StringBuffer, and StringBuilder (Objective 3.1)
  1. String objects are immutable, and String reference variables are not.
  2. If you create a new String without assigning it, it will be lost to your program.
  3. If you redirect a String reference to a new String, the old String can be lost.
  4. String methods use zero-based indexes, except for the second argument of substring().
  5. The String class is final-its methods can't be overridden.
  6. When the JVM finds a String literal, it is added to the String literal pool.
  7. Strings have a method: length(); arrays have an attribute named length.
  8. The StringBuffer's API is the same as the new StringBuilder's API, except that StringBuilder's methods are not synchronized for thread safety.
  9. StringBuilder methods should run faster than StringBuffer methods.
  10. All of the following bullets apply to both StringBuffer and StringBuilder:
    1. They are mutable - they can change without creating a new object.
    2. StringBuffer methods act on the invoking object, and objects can change without an explicit assignment in the statement.
    3. StringBuffer equals() is not overridden; it doesn't compare values.
  11. Remember that chained methods are evaluated from left to right.
  12. String methods to remember: charAt(), concat(), equalsIgnoreCase(), length(), replace(), substring(), toLowerCase(), toString(), toUpperCase(), and trim().
  13. StringBuffer methods to remember: append(), delete(), insert(), reverse(), and toString().


File I/O (Objective 3.2)
  1. The classes you need to understand in java.io are File, FileReader, BufferedReader, FileWriter, BufferedWriter, PrintWriter, and Console.
  2. A new File object doesn't mean there's a new file on your hard drive.
  3. File objects can represent either a file or a directory.
  4. The File class lets you manage (add, rename, and delete) files and directories.
  5. The methods createNewFile() and mkdir() add entries to your file system.
  6. FileWriter and FileReader are low-level I/O classesYou can use them to write and read files, but they should usually be wrapped.
  7. Classes in java.io are designed to be "chained" or "wrapped." (This is a common use of the decorator design pattern.)
  8. It's very common to "wrap" a BufferedReader around a FileReader or a BufferedWriter around a FileWriter, to get access to higher-level (more convenient) methods.
  9. PrintWriters can be used to wrap other Writers, but as of Java 5 they can be built directly from Files or Strings.
  10. Java 5 PrintWriters have new append(), format(), and printf() methods.
  11. Console objects can read non-echoed input and are instantiated using System.console().


Serialization (Objective 3.3)
  1. The classes you need to understand are all in thejava.io package; they include: ObjectOutputStream and ObjectInputStream primarily, and FileOutputStream and FileInputStream because you will use them to create the low-level streams that the ObjectXxxStream classes will use.
  2. A class must implement Serializable before its objects can be serialized.
  3. The ObjectOutputStream.writeObject() method serializes objects, and the ObjectInputStream.readObject() method deserializes objects.
  4. If you mark an instance variable transient, it will not be serialized even thought the rest of the object's state will be.
  5. You can supplement a class's automatic serialization process by implementing the writeObject() and readObject() methodsIf you do this, embedding calls to defaultWriteObject() and defaultReadObject(),respectively, will handle the part of serialization that happens normally.
  6. If a superclass implements Serializable, then its subclasses do automatically.
  7. If a superclass doesn't implement Serializable, then when a subclass object is deserialized, the superclass constructor will be invoked, along with its superconstructor(s).
  8. DataInputStream and DataOutputStream aren't actually on the exam, inspite of what the Sun objectives say.


Dates, Numbers, and Currency (Objective 3.4)
  1. The classes you need to understand are java.util.Date, java.util.Calendar, java.text.DateFormat, java.text.NumberFormat, and java.util.Locale.
  2. Most of the Date class's methods have been deprecated.
  3. A Date is stored as a long, the number of milliseconds since January 1, 1970.
  4. Date objects are go-betweens the Calendar and Locale classes.
  5. The Calendar provides a powerful set of methods to manipulate dates, performing tasks such as getting days of the week, or adding some number of months or years (or other increments) to a date.
  6. Create Calendar instances using static factory methods (getInstance()).
  7. The Calendar methods you should understand are add(), which allows you to add or subtract various pieces (minutes, days, years, and so on)  of dates, and roll(), which works like add() but doesn't increment a date's bigger pieces(For example: adding 10 months to an October date changes the month to August, but doesn't increment the Calendar's year value.)
  8. DateFormat instances are created using static factory methods (getInstance() and getDateInstance()).
  9. There are several format "styles" available in the DateFormat class.
  10. DateFormat styles can be applied against various Locales to create a wide array of outputs for any given date.
  11. The DateFormat.format() method is used to create Strings containing properly formatted dates.
  12. The Locale class is used in conjunction with DateFormat and NumberFormat.
  13. Both DateFormat and NumberFormat objects can be constructed with a specific, immutable Locale.
  14. For the exam you should understand creating Locales using language, or a combination of language and country.

Parsing, Tokenizing, and Formatting (Objective 3.5)
  1. regex is short for regular expressions, which are the patterns used to search for data within large data sources.
  2. regex is a sub-language that exists in Java and other languages (such as Perl).
  3. regex lets you to create search patterns using literal characters or metacharactersMetacharacters allow you to search for slightly more abstract data like "digits" or "whitespace".
  4. Study the \d, \s, \w, and metacharacters
  5. regex provides for quantifiers which allow you to specify concepts like: "look for one or more digits in a row."
  6. Study the ?, *, and + greedy quantifiers.
  7. Remember that metacharacters and Strings don't mix well unless you remember to "escape" them properlyFor instance String s = "\\d";
  8. The Pattern and Matcher classes have Java's most powerful regex capabilities.
  9. You should understand the Pattern compile() method and the Matcher matches(), pattern(), find(), start(), and group() methods.
  10. You WON'T need to understand Matcher's replacement-oriented methods.
  11. You can use java.util.Scanner to do simple regex searches, but it is primarily intended for tokenizing.
  12. Tokenizing is the process of splitting delimited data into small pieces.
  13. In tokenizing, the data you want is called tokens, and the strings that separate the tokens are called delimiters.
  14. Tokenizing can be done with the Scanner class, or with String.split().
  15. Delimiters are single characters like commas, or complex regex expressions.
  16. The Scanner class allows you to tokenize data from within a loop, which allows you to stop whenever you want to.
  17. The Scanner class allows you to tokenize Strings or streams or files.
  18. The String.split() method tokenizes the entire source data all at once, so large amounts of data can be quite slow to process.
  19. New to Java 5 are two methods used to format data for output. These methods are format() and printf()These methods are found in the PrintStream class, an instance of which is the out in System.out.
  20. The format() and printf() methods have identical functionality.
  21. Formatting data with printf() (or format()) is accomplished using formatting strings that are associated with primitive or string arguments.
  22. The format() method allows you to mix literals in with your format strings.
  23. The format string values you should know are
    1. Flags: -, +, 0, "," , and (
    2. Conversions: b, c, d, f, and s
  24. If your conversion character doesn't match your argument type, an exception will be thrown.

regards,
Agni..
Executive,
Talent Sprint
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses
Posted by at No comments:
Labels: , , , , , , ,

Friday, August 3, 2012

Exercise-4 (Operators)




1. Given: 
class Hexy {
 public static void main(String[] args) {
  Integer i = 42;
  String s = (i<40 i="i" life="life">50)?"universe":"everything";
  System.out.println(s);
 }
}

What is the result?
A. null
B. life
C. universe
D. everything
E. Compilation fails
F. An exception is thrown at runtime
Answer:
D is correct. This is a ternary nested in a ternary with a little unboxing thrown in. Both of the ternary expressions are false.
A, B, C, E, and F are incorrect based on the above.(Objective 7.6)
2. Given:
class Comp2 {
 public static void main(String[] args) {
  float f1 = 2.3f;
  float[][] f2 = {{42.0f}, {1.7f, 2.3f}, {2.6f, 2.7f}};
  float[] f3 = {2.7f};
  Long x = 42L;
  // insert code here
  System.out.println("true");
 }
}
And the following five code fragments:
F1. if(f1 == f2)
F2. if(f1 == f2[2][1])
F3. if(x == f2[0][0])
F4. if(f1 == f2[1,1])
F5. if(f3 == f2[2])
What is true?
 A. One of them will compile, only one will be true
B. Two of them will compile, only one will be true
C. Two of them will compile, two will be true
D. Three of them will compile, only one will be true
E. Three of them will compile, exactly two will be true
F. Three of them will compile, exactly three will be true
Answer:
D is correct. Fragments F2, F3, and F5 will compile, and only F3 is true.
A, B, C, E, and F are incorrect. F1 is incorrect because you can’t compare a primitive to an array. F4 is incorrect syntax to access an element of a two-dimensional array.(Objective 7.6)
3. Given:
class Fork {
 public static void main(String[] args) {
  if(args.length == 1 | args[1].equals("test")) {
   System.out.println("test case");
  } else {
   System.out.println("production " + args[0]);
  }
}
}
And the command-line invocation:
java Fork live2
What is the result?
A. test case
B. production live2
C. test case live2
D. Compilation fails
E. An exception is thrown at runtime
Answer:
E is correct. Because the short circuit (||) is not used, both operands are evaluated. Sinceargs[1] is past the args array bounds, an ArrayIndexOutOfBoundsException is thrown.
A, B, C, and D are incorrect based on the above. (Objective 7.6)
4. Given:
class Feline {
 public static void main(String[] args) {
  Long x = 42L;
  Long y = 44L;
  System.out.print(" " + 7 + 2 + " ");
  System.out.print(foo() + x + 5 + " ");
  System.out.println(x + y + foo());
 }
 static String foo() { return "foo"; }
}
What is the result?
A. 9 foo47 86foo
B. 9 foo47 4244foo
C. 9 foo425 86foo
D. 9 foo425 4244foo
E. 72 foo47 86foo
F. 72 foo47 4244foo
G. 72 foo425 86foo
H. 72 foo425 4244foo
I. Compilation fails
Answer:
G is correct. Concatenation runs from left to right, and if either operand is a String,the operands are concatenated. If both operands are numbers they are added together.Unboxing works in conjunction with concatenation.
A, B, C, D, E, F, H, and I are incorrect based on the above. (Objective 7.6)
5. Place the fragments into the code to produce the output 33. Note, you must use each fragment exactly once.
CODE:
class Incr {
 public static void main(String[] args) {
  Integer x = 7;
  int y = 2;
  x ___ ___;
  ___ ___ ___;
  ___ ___ ___;
  ___ ___ ___;
  System.out.println(x);
 }
}
FRAGMENTS:
yyyy
yxx
-=*=*=*=
Answer: 
class Incr {
 public static void main(String[] args) {
  Integer x = 7;
  int y = 2;
  x *= x;
  y *= y;
  y *= y;
  x -= y;
  System.out.println(x);
 }
}
Yeah, we know it’s kind of puzzle-y, but you might encounter something like it on the real exam. (Objective 7.6)
6. Given:
public class Twisty {
 { index = 1; }
 int index;
 public static void main(String[] args) {
  new Twisty().go();
 }
 void go() {
  int [][] dd = {{9,8,7}, {6,5,4}, {3,2,1,0}};
  System.out.println(dd[index++][index++]);
 }
}
What is the result? (Choose all that apply.)
A. 1
B. 2
C. 4
D. 6
E. 8
F. Compilation fails
G. An exception is thrown at runtime
Answer:
C is correct. Multidimensional arrays' dimensions can be inconsistent, the code uses an initialization block, and the increment operators are both post-increment operators.
A, B, D, E, F, and G are incorrect based on the above. (Objective 1.3)
7. Given:
import java.lang.*;
import java.io.*; 
public class McGee {
 public static void main(String[] args) {
  Days d1 = Days.TH;
  Days d2 = Days.M;
  for(Days d: Days.values()) {
   if(d.equals(Days.F)) break;
   d2 = d;
  }
  System.out.println((d1 == d2)?"same old" : "newly new");
 }
 enum Days {M, T, W, TH, F, SA, SU};
}
What is the result?
A. same old
B. newly new
C. Compilation fails due to multiple errors
D. Compilation fails due only to an error on line 7
E. Compilation fails due only to an error on line 8
F. Compilation fails due only to an error on line 11
G. Compilation fails due only to an error on line 13
Answer:
A is correct. All of this syntax is correct. The for-each iterates through the enum using the values() method to return an array. Enums can be compared using either equals() or ==. Enums can be used in a ternary operator's Boolean test.
B, C, D, E, F, and G are incorrect based on the above. (Objective 7.6)
8. Given:
public class SpecialOps {
 public static void main(String[] args) {
  String s = "";
  Boolean b1 = true;
  Boolean b2 = false;
  if((b2 = false) | (21%5) > 2) s += "x";
  if(b1 || (b2 = true)) s += "y";
  if(b2 == true) s += "z";
  System.out.println(s);
 }
}
Which are true? (Choose all that apply.)
A. Compilation fails
B. x will be included in the output
C. y will be included in the output
D. z will be included in the output
E. An exception is thrown at runtime
Answer:
C is correct. First of all, boxing takes care of the Boolean. Line 9 uses the modulus operator, which returns the remainder of the division, which in this case is 1. Also, line 9 sets b2 to false, and it doesn't test b2's value. Line 10 sets b2 to true, and it doesn’t test its value; however, the short circuit operator keeps the expression b2 = true from being executed.
A, B, D, and E are incorrect based on the above. (Objective 7.6)
9. Given:

public class Spock {
 public static void main(String[] args) {
  int mask = 0;
  int count = 0;
  if( ((5 < 7) || (++count < 10)) | mask++ < 10 ) mask = mask + 1;
  if( (6 > 8) ^ false) mask = mask + 10;
  if( !(mask > 1) && ++count > 1) mask = mask + 100;
  System.out.println(mask + " " + count);
 }
}
Which two answers are true about the value of mask and the value of count at line 10?(Choose two.)
A. mask is 0
B. mask is 1
C. mask is 2
D. mask is 10
E. mask is greater than 10
F. count is 0
G. count is greater than 0
Answer:
C and F are correct. At line 7 the || keeps count from being incremented, but the | allows mask to be incremented. At line 8 the ^ returns true only if exactly one operand is true. At line 9 mask is 2 and the && keeps count from being incremented.
A, B, D, E, and G are incorrect based on the above. (Objective 7.6)
10. Given:
interface Vessel { }
interface Toy { }
class Boat implements Vessel { }
class Speedboat extends Boat implements Toy { }

public class Tree {
 public static void main(String[] args) {
  String s = "0";
  Boat b = new Boat();
  Boat b2 = new Speedboat();
  Speedboat s2 = new Speedboat();
  if((b instanceof Vessel) && (b2 instanceof Toy)) s += "1";
  if((s2 instanceof Vessel) && (s2 instanceof Toy)) s += "2";
  System.out.println(s);
 }
}
What is the result?
A. 0
B. 01
C. 02
D. 012
E. Compilation fails
F. An exception is thrown at runtime
Answer:
D is correct. First, remember that instanceof can look up through multiple levels of an inheritance tree. Also remember that instanceof is commonly used before attempting a downcast, so in this case, after line 15, it would be possible to say Speedboat s3 = (Speedboat)b2;.
A, B, C, E, and F are incorrect based on the above. (Objective 7.6)

regards,
Agni..
Executive,
Talent Sprint
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses
Posted by at No comments:
Labels: , , , , ,

Wednesday, August 1, 2012

Operators


Relational Operators (Objective 7.6)
  1. Relational operators always result in a boolean value (true or false).
  2. There are six relational operators: >, >=, <, <=, ==, and !=. 
  3. The last two (== and !=) are sometimes referred to as equality operators.
  4. When comparing characters, Java uses the Unicode value of the character as the numerical value.
Equality operators
  1. There are two equality operators: == and != .
  2. Four types of things can be tested: numbers, characters, booleans, and reference variables.
  3. When comparing reference variables, == returns true only if both references refer to the same object. 
instanceof Operator (Objective 7.6)
  1. instanceof is for reference variables only, and checks for whether the object is of a particular type.
  2. The instanceof operator can be used only to test objects (or null) against class types that are in the same class hierarchy.
  3. For interfaces, an object passes the instanceof test if any of its superclasses implement the interface on the right side of the instanceof operator.
Arithmetic Operators (Objective 7.6)
  1. There are four primary math operators: add, subtract, multiply, and divide.
  2. The remainder operator (%), returns the remainder of a division.
  3. Expressions are evaluated from left to right, unless you add parentheses, or unless some operators in the expression have higher precedence than others.
  4. The *, /, and % operators have higher precedence than + and -.
String Concatenation Operator (Objective 7.6)
  1. If either operand is a String, the + operator concatenates the operands. 
  2. If both operands are numeric, the + operator adds the operands.
Increment/Decrement Operators (Objective 7.6)
  1. Prefix operators (++ and --) run before the value is used in the expression.
  2. Postfix operators (++ and --) run after the value is used in the expression.
  3. In any expression, both operands are fully evaluated before the operator is applied.
  4. Variables marked final cannot be incremented or decremented.
Ternary (Conditional Operator) (Objective 7.6)
  1. Returns one of two values based on whether a boolean expression is true or false.
  2. Returns the value after the ? if the expression is true.
  3. Returns the value after the : if the expression is false.
Logical Operators (Objective 7.6)
  1. The exam covers six "logical" operators: &, |, ^, !, &&, and ||.
  2. Logical operators work with two expressions (except for !) that must resolve to boolean values.
  3. The && and & operators return true only if both operands are true.
  4. The || and | operators return true if either or both operands are true.
  5. The && and || operators are known as short-circuit operators.
  6. The && operator does not evaluate the right operand if the left operand is false.
  7. The || does not evaluate the right operand if the left operand is true.
  8. The & and | operators always evaluate both operands.
  9. The ^ operator (called the "logical XOR"), returns true if exactly one operand is true.
  10. The ! operator (called the "inversion" operator), returns the opposite value of the boolean operand it precedes.


regards,
Agni..
Executive,
Talent Sprint
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses

Posted by at No comments:
Labels: , , , , ,

Sunday, July 29, 2012

OCPJ Exercise-3 (Basics)






1. Given: 
class CardBoard {
 Short story = 200;
 
 CardBoard go(CardBoard cb) {
  cb = null;
  return cb;
 }

 public static void main(String[] args) {
  CardBoard c1 = new CardBoard();
  CardBoard c2 = new CardBoard();
  CardBoard c3 = c1.go(c2);
  
  c1 = null;
  // do Stuff
 } 
}

When // doStuff is reached, how many objects are eligible for GC?
A. 0
B. 1
C. 2
D. Compilation fails
E. It is not possible to know
F. An exception is thrown at runtime
Answer:
C is correct. Only one CardBoard object (c1) is eligible, but it has an associated Short wrapper object that is also eligible.
A, B, D, E, and F are incorrect based on the above. (Objective 7.4)
2. Given:
class Alien {
String invade(short ships) { return "a few"; }
String invade(short... ships) { return "many"; }
}
class Defender {
public static void main(String [] args) {
System.out.println(new Alien().invade(7));
} }
What is the result?
A. many
B. a few
C. Compilation fails
D. The output is not predictable
E. An exception is thrown at runtime
Answer:
C is correct, compilation fails. The var-args declaration is fine, but invade takes a short,so the argument 7 needs to be cast to a short. With the cast, the answer is B, 'a few'.
A, B, D, and E are incorrect based on the above. (Objective 1.3)
3. Given: 
class Dims {
 public static void main(String[] args) {
  int[][] a = {{1,2,}, {3,4}};
  int[] b = (int[]) a[1];
  Object o1 = a;
  int[][] a2 = (int[][]) o1;
  int[] b2 = (int[]) o1;
  System.out.println(b[1]);
 } 
}
What is the result?
A. 2
B. 4
C. An exception is thrown at runtime
D. Compilation fails due to an error on line 4
E. Compilation fails due to an error on line 5
F. Compilation fails due to an error on line 6
G. Compilation fails due to an error on line 7
Answer:
C is correct. A ClassCastException is thrown at line 7 because o1 refers to an int[][] not an int[]. If line 7 was removed, the output would be 4.
A, B, D, E, F, and G are incorrect based on the above. (Objective 1.3)
4. Given: 
class Mixer {
 Mixer() { }
 Mixer(Mixer m) { m1 = m; }
 Mixer m1;

 public static void main(String[] args) {
  Mixer m2 = new Mixer();
  Mixer m3 = new Mixer(m2); m3.go();
  Mixer m4 = m3.m1; m4.go();
  Mixer m5 = m2.m1; m5.go();
 }

 void go() { 
  System.out.print("hi "); 
 }
}
What is the result?
A. hi
B. hi hi
C. hi hi hi
D. Compilation fails
E. hi, followed by an exception
F. hi hi, followed by an exception
Answer:
F is correct. The m2 object's m1 instance variable is never initialized, so when m5 tries to use it a NullPointerException is thrown.
A, B, C, D, and E are incorrect based on the above. (Objective 7.3)
5. Given: 
class Fizz {
 int x = 5;

 public static void main(String[] args) {
  final Fizz f1 = new Fizz();
  Fizz f2 = new Fizz();
  Fizz f3 = FizzSwitch(f1,f2);
  System.out.println((f1 == f3) + " " + (f1.x == f3.x));
 }

 static Fizz FizzSwitch(Fizz x, Fizz y) {
  final Fizz z = x;
  z.x = 6;
  return z;
 }
}
What is the result?
A. true true
B. false true
C. true false
D. false false
E. Compilation fails
F. An exception is thrown at runtime
Answer:
A is correct. The references f1, z, and f3 all refer to the same instance of Fizz. The final modifier assures that a reference variable cannot be referred to a different object, but final doesn't keep the object's state from changing.
B, C, D, E, and F are incorrect based on the above. (Objective 7.3)
6. Given: 
class Bird {
 
 { System.out.print("b1 "); }
 
 public Bird() { System.out.print("b2 "); }
}
class Raptor extends Bird {
 static { System.out.print("r1 "); }
 
 public Raptor() { System.out.print("r2 "); }
 
 { System.out.print("r3 "); }

 static { System.out.print("r4 "); }
}
class Hawk extends Raptor {
 public static void main(String[] args) {
  System.out.print("pre ");
  new Hawk();
  System.out.println("hawk ");
 }
}
What is the result?
A. pre b1 b2 r3 r2 hawk
B. pre b2 b1 r2 r3 hawk
C. pre b2 b1 r2 r3 hawk r1 r4
D. r1 r4 pre b1 b2 r3 r2 hawk
E. r1 r4 pre b2 b1 r2 r3 hawk
F. pre r1 r4 b1 b2 r3 r2 hawk
G. pre r1 r4 b2 b1 r2 r3 hawk
H. The order of output cannot be predicted
I. Compilation fails
Answer:
D is correct. Static init blocks are executed at class loading time, instance init blocks run right after the call to super() in a constructor. When multiple init blocks of a single type occur in a class, they run in order, from the top down.
A, B, C, E, F, G, H, and I are incorrect based on the above. Note: you'll probably never see this many choices on the real exam! (Objective 1.3)
7. Given: 
public class Bridge {
 public enum Suits {
  CLUBS(20), DIAMONDS(20), HEARTS(30), SPADES(30),
  NOTRUMP(40) { public int getValue(int bid) {
  return ((bid-1)*30)+40; } };
  Suits(int points) { this.points = points; }
  private int points;
  public int getValue(int bid) { return points * bid; }
 }
 public static void main(String[] args) {
  System.out.println(Suits.NOTRUMP.getBidValue(3));
  System.out.println(Suits.SPADES + " " + Suits.SPADES.points);
  System.out.println(Suits.values());
 }
}
Which are true? (Choose all that apply.)
A. The output could contain 30
B. The output could contain @bf73fa
C. The output could contain DIAMONDS
D. Compilation fails due to an error on line 4
E. Compilation fails due to an error on line 5
F. Compilation fails due to an error on line 6
G. Compilation fails due to an error on line 7
H. Compilation fails due to an error within lines 10 to 12
Answer:
A and B are correct. The code compiles and runs without exception. The values() method returns an array reference, not the contents of the enum, so DIAMONDS is never printed.
C, D, E, F, G, and H are incorrect based on the above. (Objective 1.3)
8. Given:
public class Ouch {
 static int ouch = 7;
 public static void main(String[] args) {
  new Ouch().go(ouch);
  System.out.print(" " + ouch);
 }
 void go(int ouch) {
  ouch++;
 for(int ouch = 3; ouch < 6; ouch++)
  ;
 System.out.print(" " + ouch);
 }
}
What is the result?
A. 5 7
B. 5 8
C. 8 7
D. 8 8
E. Compilation fails
F. An exception is thrown at runtime
Answer:
E is correct. The parameter declared on line 7 is valid (although ugly), but the variable name ouch cannot be declared again on line 9 in the same scope as the declaration on line 7.
A, B, C, D, and F are incorrect based on the above. (Objective 1.3)
9. Given: 
public class Bertha {
 static String s = "";
 public static void main(String[] args) {
  int x = 4; Boolean y = true; short[] sa = {1,2,3};
  doStuff(x, y);
  doStuff(x);
  doStuff(sa, sa);
  System.out.println(s);
 }
 static void doStuff(Object o) { s += "1"; }
 static void doStuff(Object... o) { s += "2"; }
 static void doStuff(Integer... i) { s += "3"; }
 static void doStuff(Long L) { s += "4"; }
}
What is the result?
A. 212
B. 232
C. 234
D. 312
E. 332
F. 334
G. Compilation fails
Answer:
A is correct. It's legal to autobox and then widen. The first call to doStuff() boxes the int to an Integer then passes two objects. The second call cannot widen and then box (making the Long method unusable), so it boxes the int to an Integer. As always, a var-args method will be chosen only if no non-var-arg method is possible. The third call is passing two objects—they are of type 'short array.'
B, C, D, E, F, and G are incorrect based on the above. (Objective 3.1)
10. Given: 
class Dozens {
 int[] dz = {1,2,3,4,5,6,7,8,9,10,11,12};
}
public class Eggs {
 public static void main(String[] args) {
  Dozens [] da = new Dozens[3];
  da[0] = new Dozens();
  Dozens d = new Dozens();
  da[1] = d;
  d = null;
  da[1] = null;
  // do stuff
 }
}
Which two are true about the objects created within main(), and eligible for garbage collection when line 12 is reached?
A. Three objects were created
B. Four objects were created
C. Five objects were created
D. Zero objects are eligible for GC
E. One object is eligible for GC
F. Two objects are eligible for GC
G. Three objects are eligible for GC
Answer:
C and F are correct. da refers to an object of type "Dozens array," and each Dozens object that is created comes with its own "int array" object. When line 14 is reached, only the second Dozens object (and its "int array" object) are not reachable.
A, B, D, E, and G are incorrect based on the above. (Objective 7.4)
11. Given: 
class Beta { }
class Alpha {
 static Beta b1;
 Beta b2;
}
public class Tester {
 public static void main(String[] args) {
  Beta b1 = new Beta(); Beta b2 = new Beta();
  Alpha a1 = new Alpha(); Alpha a2 = new Alpha();
  a1.b1 = b1;
  a1.b2 = b1;
  a2.b2 = b2;
  a1 = null; b1 = null; b2 = null;
  // do stuff
 }
}
When line 16 is reached, how many objects will be eligible for garbage collection?
A. 0
B. 1
C. 2
D. 3
E. 4
F. 5
Answer:
B is correct. It should be clear that there is still a reference to the object referred to by a2, and that there is still a reference to the object referred to by a2.b2. What might be less clear is that you can still access the other Beta object through the static variable a2.b1—because it's static.
A, C, D, E, and F are incorrect based on the above. (Objective 7.4)
12. Given: 
class Box {
 int size;
 Box(int s) { size = s; }
}
public class Laser {
 public static void main(String[] args) {
  Box b1 = new Box(5);
  Box[] ba = go(b1, new Box(6));
  ba[0] = b1;
  for(Box b : ba) System.out.print(b.size + " ");
 }
 static Box[] go(Box b1, Box b2) {
  b1.size = 4;
  Box[] ma = {b2, b1};
  return ma;
 }
}
What is the result?
A. 4 4
B. 5 4
C. 6 4
D. 4 5
E. 5 5
F. Compilation fails
Answer:
A is correct. Although main()'s b1 is a different reference variable than go()'s b1, they refer to the same Box object.
B, C, D, E, and F are incorrect based on the above. (Objective 7.3)
13. Given: 
public class Dark {
 int x = 3;
 public static void main(String[] args) {
  new Dark().go1();
 }
 void go1() {
  int x;
  go2(++x);
 }
 void go2(int y) {
  int x = ++y;
  System.out.println(x);
 }
}
what is the result?
A. 2
B. 3
C. 4
D. 5
E. Compilation fails
F. An exception is thrown at runtime
Answer:
E is correct. In go1() the local variable x is not initialized.
A, B, C, D, and F are incorrect based on the above. (Objective 1.3)


regards,
Agni..
Executive,
Talent Sprint Edu. Pvt Ltd.
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses


Posted by at No comments:
Labels: , , , , ,

Thursday, July 26, 2012

Basic Points


Bullet Points on some Basic Concepts:

Stack and Heap
  • Local variables (method variables) live on the stack.
  • Objects and their instance variables live on the heap.
Literals and Primitive Casting (Objective 1.3)
  • Integer literals can be decimal, octal (e.g. 013), or hexadecimal (e.g. 0x3d).
  • Literals for longs end in L or l.
  • Float literals end in F or f, double literals end in a digit or D or d.
  • The boolean literals are true and false.
  • Literals for chars are a single character inside single quotes: 'd'.
Scope (Objectives 1.3 and 7.6)
  • Scope refers to the lifetime of a variable.
  • There are four basic scopes:
    • Static variables live basically as long as their class lives.
    • Instance variables live as long as their object lives.
    • Local variables live as long as their method is on the stack; however, if their method invokes another method, they are temporarily unavailable.
    • Block variables (e.g., in a for or an if) live until the block completes.
Basic Assignments (Objectives 1.3 and 7.6)
  • Literal integers are implicitly ints.
  • Integer expressions always result in an int-sized result, never smaller.
  • Floating-point numbers are implicitly doubles (64 bits).
  • Narrowing a primitive truncates the high order bits.
  • Compound assignments (e.g. +=), perform an automatic cast.
  • A reference variable holds the bits that are used to refer to an object.
  • Reference variables can refer to subclasses of the declared type but not to superclasses.
  • When creating a new object, e.g., Button b = new Button(); three things happen:
    • Make a reference variable named b, of type Button
    • Create a new Button object
    • Assign the Button object to the reference variable b 
Using a Variable or Array Element That Is Uninitialized and Unassigned (Objectives 1.3 and 7.6)
  • When an array of objects is instantiated, objects within the array are not instantiated automatically, but all the references get the default value of null.
  • When an array of primitives is instantiated, elements get default values.
  • Instance variables are always initialized with a default value.
  • Local/automatic/method variables are never given a default value. If you attempt to use one before initializing it, you'll get a compiler error.
Passing Variables into Methods (Objective 7.3)
  • Methods can take primitives and/or object references as arguments.
  • Method arguments are always copies.
  • Method arguments are never actual objects (they can be references to objects).
  • A primitive argument is an unattached copy of the original primitive.
  • A reference argument is another copy of a reference to the original object.
  • Shadowing occurs when two variables with different scopes share the same name. This leads to hard-to-find bugs, and hard-to-answer exam questions.
Array Declaration, Construction, and Initialization (Obj. 1.3)
  • Arrays can hold primitives or objects, but the array itself is always an object.
  • When you declare an array, the brackets can be left or right of the name.
  • It is never legal to include the size of an array in the declaration.
  • You must include the size of an array when you construct it (using new) unless you are creating an anonymous array.
  • Elements in an array of objects are not automatically created, although primitive array elements are given default values.
  • You'll get a NullPointerException if you try to use an array element in an object array, if that element does not refer to a real object.
  • Arrays are indexed beginning with zero.
  • An ArrayIndexOutOfBoundsException occurs if you use a bad index value.
  • Arrays have a length variable whose value is the number of array elements.
  • The last index you can access is always one less than the length of the array.
  • Multidimensional arrays are just arrays of arrays.
  • The dimensions in a multidimensional array can have different lengths.
  • An array of primitives can accept any value that can be promoted implicitly to the array's declared type;. e.g., a byte variable can go in an int array.
  • An array of objects can hold any object that passes the IS-A (or instanceof) test for the declared type of the array. For example, if Horse extends Animal, then a Horse object can go into an Animal array.
  • If you assign an array to a previously declared array reference, the array you're assigning must be the same dimension as the reference you're assigning it to.
  • You can assign an array of one type to a previously declared array reference of one of its supertypes. For example, a Honda array can be assigned to an array declared as type Car (assuming Honda extends Car).
Initialization Blocks (Objectives 1.3 and 7.6)
  • Static initialization blocks run once, when the class is first loaded.
  • Instance initialization blocks run every time a new instance is created. They run after all super-constructors and before the constructor's code has run.
  • If multiple init blocks exist in a class, they follow the rules stated above, AND they run in the order in which they appear in the source file.
Using Wrappers (Objective 3.1)
  • The wrapper classes correlate to the primitive types.
  • Wrappers have two main functions:
    • To wrap primitives so that they can be handled like objects
    • To provide utility methods for primitives (usually conversions)
  • The three most important method families are
    • xxxValue() Takes no arguments, returns a primitive
    • parseXxx() Takes a String, returns a primitive, throws NFE
    • valueOf() Takes a String, returns a wrapped object, throws NFE
  • Wrapper constructors can take a String or a primitive, except for Character, which can only take a char.
  • Radix refers to bases (typically) other than 10; octal is radix = 8, hex = 16. 
Boxing (Objective 3.1)
  • As of Java 5, boxing allows you to convert primitives to wrappers or to convert wrappers to primitives automatically.
  • Using == with wrappers created through boxing is tricky; those with the same small values (typically lower than 127), will be ==, larger values will not be ==.
Advanced Overloading (Objectives 1.5 and 5.4)
  • Primitive widening uses the "smallest" method argument possible.
  • Used individually, boxing and var-args are compatible with overloading.
  • You CANNOT widen from one wrapper type to another. (IS-A fails.)
  • You CANNOT widen and then box. (An int can't become a Long.)
  • You can box and then widen. (An int can become an Object, via an Integer.)
  • You can combine var-args with either widening or boxing.
Garbage Collection (Objective 7.4)
  • In Java, garbage collection (GC) provides automated memory management.
  • The purpose of GC is to delete objects that can't be reached.
  • Only the JVM decides when to run the GC, you can only suggest it.
  • You can't know the GC algorithm for sure.
  • Objects must be considered eligible before they can be garbage collected.
  • An object is eligible when no live thread can reach it.
  • To reach an object, you must have a live, reachable reference to that object.
  • Java applications can run out of memory.
  • Islands of objects can be GCed, even though they refer to each other.
  • Request garbage collection with System.gc();
  • Class Object has a finalize() method.
  • The finalize() method is guaranteed to run once and only once before the garbage collector deletes an object.
  • The garbage collector makes no guarantees, finalize() may never run.
  • You can uneligibilize an object for GC from within finalize().

regards,

M.Agni..
Executive,
Talent Sprint Edu. Pvt Ltd.
Hyderabad.


for Feedback and Support simply drop a mail in
agni2020{at}gmail.com
Remember to replace the {at} with @ in the email addresses
Posted by at No comments:
Labels: , , , , ,
Subscribe to: Posts (Atom)

AdSense