Q1. How would you go about choosing the right data types for your application?
A1. Java is what is known as a strongly typed language. This means Java only accepts specific values within specific variables or parameters. Some languages, such as JavaScript, PHP, and Perl are weakly typed languages.
1. Know the data limits to prevent any data overflow
Java primitive data types
|
1 2 3 4 5 6 |
int bad = 2100000000; // Close to int max value. long good = 2100000000L; long badAgain = 9000000000000000000L; // Close to long max value BigInteger goodAgain = BigInteger .valueOf(9000000000000000000L); |
2. Prefer immutable wrapper objects to primitives.
Each primitive data type has a corresponding wrapper class like Integer, Long, Character, Float, Double, etc. There are 8 primitive variables and as many wrapper objects. In Java 5, additional wrapper classes like AtomicInteger, AtomicLong, AtomicBoolean and AtomicReference
Q2. What are wrapper classes, and why do you need them?
A2. The wrapper classes are a good example of the decorator design pattern. They decorate the primitive values, and enhance their behavior by providing immutability, atomicity, null checking, etc.
1) Wrapper objects can be initialized to null. This can’t be done with primitives. Many programmers initialize numbers to 0 or -1 to signify default values, but depending on the scenario, this may be incorrect or misleading.
2) Wrapper objects are very useful for optional data. Databases almost always have a significant fraction of their fields as optional (that is, as possibly NULL). In addition, the forms submitted in Web applications can contain optional parameters. Both NULL database fields and missing request parameters naturally map to null object references. With primitives, there is no such natural mapping.
3) Wrapper objects will also set the scene for a NullPointerException when something is being used incorrectly, which is much more programmer-friendly as it fails fast than some arbitrary exception buried down the line. Preferably, check for null early on in the method and report it immediately where applicable to adhere to the fail fast principle.
4) The wrapper objects are immutable, hence inherently thread-safe. Other threads can only read the values set by the thread that initialized this object.
5) When you create wrapper objects, use the valueOf( ) static factory method for efficiency.
|
1 2 3 |
Integer i2 = new Integer(5); //first approach is okay Integer i1 = Integer.valueOf(5); //2nd approach is more efficient |
The second approach is in fact an implementation of the flyweight design pattern.
Q. When to prefer primitives?
A. Primitives are faster to create and use than wrapper objects. Wrapper objects need to be auto-unboxed before use. Thus there is an extra step for the JVM to perform. For example, in order to perform arithmetic on an Integer, it must first be converted to an int before the arithmetic can be performed. In many business applications this rarely matters unless you were writing something very number-crunching or profiling indicates that the auto-boxing is a performance or memory issue in a particular part of your code as it is executed very frequently.
Anti-pattern: Watch out for premature-optimization anti-pattern where you are tempted to code for a perceived performance gain and sacrificing good design and maintainability.
Q3. When working with floating-point data types, what are some of the key considerations?
A3.
1. Never compare float or double with “==” or != operator
|
1 2 3 4 |
//endless loop -- don't compare float or double for == or != for (float f = 5f; f != 10.0; f += 0.1) { System.out.println(f); } |
2. Use long, int, or BigDecimal for storing money, and performing monetary calculations.
Floating point data types like float, double, Float, or Double can result in inaccurate results. use either the BigDecimal or int/long representing the value in its lowest units like cents.
|
1 2 3 4 5 6 7 8 9 10 |
private void calculateTotalAccurately1(float unitCost, int itemCount){ BigDecimal total = BigDecimal.ZERO; //use the right constructor BigDecimal uc = new BigDecimal(String.valueOf(unitCost)); BigDecimal ic= new BigDecimal(String.valueOf(itemCount)); total = uc.multiply(ic); total = total.setScale(2, RoundingMode.HALF_EVEN); System.out.println("Total3 --> " + total); // 30.00 – good } |
Q4. What is your understanding of widening versus narrowing conversions of primitive data types?
A4. Left to right (e.g. byte to short) is a widening conversion and considered safe because there is no chance for data loss. For example, byte has a range between -128 and 127 and short has a wider range between -32768 and 32767. So when you go from left to right, the data types are implicitly cast by the compiler since it is safe to do so.
Java primitive data types
Right to left (e.g. short to byte) is a narrowing conversion and considered unsafe because there is a chance for data loss. So when you go from right to left, the compiler expects you to explicitly cast the data to clearly state that it is safe to do so. If you do not cast explicitly, you will get a compile-time error. For example,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
byte b = 0; // valid values are -128 to 127 short s = 0; // valid values are -32768 to 32767 int i = 0; // valid values are -2147483648 to 2147483647. long l = 0L; // valid values are -9223372036854775808 to 9223372036854775807 float f = 0.0F; // valid values are 1.4E-45 to 3.4028235E38 double d = 0.0; // valid values are 4.9E-324 to 1.7976931348623157E308 b = 30; // okay (30 is of type int, but within the byte range) b = 128; // Not okay (128 is of type int, but is outside the byte range) s = b; // okay: short is wider than byte. i = s; // okay: int is wider than short. l = i; // okay: long is wider than int. /** * compile-time errors **/ c = s; // Not okay: type char is unsigned & type short is signed. b = i; // Not okay: type int is wider than byte i = l; // Not okay: type long is wider than int l = f; // Not okay: type float is wider than long f = d; // Not okay: type double is wider than float /** * fix above compile-time errors with explicit casting. **/ c = (char)s; b = (byte) i; i = (int) l; l = (long) f; f = (float) d; |
Note: byte and short are signed data types and they cannot be implicitly cast to unsigned char data type even though it is a widening conversion.
Q5. What are the dangers of explicit casting?
A5. Not knowing the MIN and MAX values can result in unexpected results due to loss of data during narrowing.
Trap #1 Be careful when casting explicitly.
|
1 2 3 4 5 6 7 8 9 |
int iWithinByteRange = 125; int iOutsideByteRangeMax = 129; byte bGood = (byte) iWithinByteRange; System.out.println("bOkay=" + bGood); // 125 – good byte bBad = (byte) iOutsideByteRangeMax; System.out.println("Trap #1 - bBad=" + bBad); // -127 – bad |
Trap #2: Simple binary operations apply ‘binary numeric promotions’
The binary numeric promotion rule automatically casts each operand to the size of the larger operand type. If neither operand is larger, then both are cast to the same type. In byte b = b + 10, the value 10 is of type int and is the larger operand type compared to b, which is of type byte, hence will be evaluated as follows:
|
1 |
byte b = (int)b + 10; |
Above code throws a compile time error because b+10 evaluates to an int. You need an explicit cast to convert an int to byte as it is a narrowing conversion.
Trap #3: Compound Operators, such as +=, -=, etc contain an explicit cast
In byte b+=10 compound binary operation, you may be thinking that b+=10 will be expanded as b = b + 10. But it is really not correct. This is because the compound operations will have an explicit cast in the converted byte code.
|
1 |
byte b = (byte) (b + 10); |
performing a compound assignment operation (e.g. +=, -=, *=, etc). You may be thinking that b+=10 will be expanded as b = b + 10. But it is really not correct. This is because the compound operations will have an explicit cast even though it is not shown in the code.
Q6. Do you think the following code will throw a compile-time exception? If yes, how will you fix it?
|
1 |
float myVal = (float)3.0/2.0; |
A6. Yes. It is cast first and then divided as casting operator has precedence over division operator as per the precedence table. So the above code is equivalent to
|
1 2 3 |
float myVal = 3.0f/2.0; // float divided by double returns a double //as per the "binary numeric promotion" principle |
To fix it, you need to get the division operator to evaluate prior to casting. You can achieve this by introducing a parenthesis around the division as parenthesis has higher precedence (in fact highest) than casting as per the precedence table.
|
1 2 3 4 |
float myVal = (float)(3.0/2.0); // double divided by double returns a // double and it is then explicitly // cast to float to return a float value. |
Q7. What is the output of the following code snippet?
|
1 2 3 4 5 6 7 8 9 10 |
public class PrePostOperators { public static void main(String[ ] args) { int x = 5; // line 1 int y = ++x; // line 2 int z = y++; // line 3 System.out.println("x=" + x + ", y=" + y + ", z=" + z); } } |
A7. x=6, y=7, z=6
line 1: x=5, y=0, z=0
line 2: x=6, y=6, z=0;
line 3: x=6, y=7, z=6
You need to understand the pre and post increment operators to get this right. ++x is a pre-increment and x++ is a post increment. ++x means x is incremented before being used and x++ means x is incremented after being used. So line2 increments x by one and then assign it to y. Whereas in line 3, z is assigned the old y value (i.e. prior to incrementing) of 6 and then y value is incremented to 7.
As you may rightly ask that as per the precedence table, both pre-increment (i.e. ++expr) and post-increment (i.e. expr++) operators do have precedence over the assignment operator (i.e “=”). The line 3 int z = y++; is roughly evaluated as follows:
|
1 2 3 4 |
int oldY = 6; // current value of y is used by storing it to a variable y = y+ 1; // increment y by 1 to 7 z = oldY; // z is set to the stored oldY value of 6 |
Q8. Can you list some practical applications where the bitwise operations can be applied?
A8.
Example 1: To pack and unpack values.
For example, to represent
- age of a person in the range of 0 to 127. Use 7 bits.
- gender of a person 0 or 1 (0 – female and 1 – male). Use 1 bit.
- height of a person in the range of 0 to 255. Use 8 bits.
To pack this info: (((age << 1) | gender ) << 8 ) | height. For example, age = 25, gender = 1, and height = 255cm. Shift the age by 1 bit, and combine it with gender, and then shift the age and gender by 8 bits and combine it with the height.
Bitwise operations
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public class Binary { public static void main(String[ ] args) { //packing int val = ((((25 << 1) | 1) << 8) | 255); System.out.println("packed=" + val); System.out.println("packed binary=" + Integer.toBinaryString(val)); //0011001111111111 //unpacking System.out.println("height=" + (val & 0xff)); //extract last 8 bits. System.out.println("gender=" + ((val >>> 8) & 1)); //extract bit 9 System.out.println("age=" + ((val >>> 9))); //extract bits 10 – 16. } } |
Output:
packed=13311
packed binary=11001111111111
height=255
gender=1
age=25
Example 2: To compactly represent a number of attributes like being bold, italics, etc of a character in a text editor.
This is a more practical example.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
import java.util.Arrays; public class Binary6 { public static void main(String[ ] args) { byte[ ] vals = { 0, 1, 0, 1, 0, 0, 0, 1 }; byte value = pack(vals); System.out.println("packedValue=" + value); // 81 System.out.println("unpackedValues=" + Arrays.toString(unpack(value))); // [0, 1, 0, 1, 0, 0, 0, 1] } public static byte pack(byte[ ] vals) { byte result = 0; for (byte bit : vals) { result = (byte) ((result << 1) | (bit & 1)); } return result; } public static byte[ ] unpack(byte val) { byte[ ] result = new byte[8]; for (int i = 0; i < 8; i++) { result[i] = (byte) ((val >> (7 - i)) & 1); } return result; } } |
Example 3: If you can think of anything as slots or switches that need to be flagged on or off,
you can think of bitwise operators. For example, if you want to mark some events on a calendar.
Example 4: To multiply or divide by 2n
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class ShiftOperator { //multiply 10 by 2 power n where n = 6 private static final int MULTIPLY = 10 << 6; //Divide 640 by 2 power n where n = 6. private static final int DIVIDE = 640 >> 6; public static void main(String[ ] args) { System.out.println(MULTIPLY); // 640 System.out.println(DIVIDE); // 10 } } |
