Java Interview Review Notes

2019-08-19

This post contains some Java language feature questions. Updating…

在此收录一些关于Java语言特性问题。更新中…

Principle Questions

Immutable Objects

Immutable objects are also useful because they are inherently thread-safe.

Data Structure

PriorityQueue

Compared with TreeSet():
- TreeSet is a set and no duplicate element;
- PriorityQueue iterator does not guarantee order;
- PriorityQueue is preferred when only need peek top element cases.
PriorityQueue is implemented by Binary Min Heap.
add() throw exception when failed, offer() return false.
element() throw exception when failed, peek() return null.
poll(), size(), remove(), clear(), toArray().
PQ does not accept null element.

HashMap

Starting from Java 8, HashMap starts with storing Entry objects in linked list but after the number of items in a hash becomes larger than a certain threshold, the hash will change from using a linked list to a balanced tree. Providing $O(\log n)$ worse case performance.
put method returns the previous value associated with key, or null if there was no mapping for key.

LinkedList

remove() is not O(n) as some blogs stated. The remove operation for a linked list is O(1), but it requires to find the to-be-removed node. So the specific remove() method in Java LinkedList is O(n).
But the remove() for iterator is O(1).

LinkedHashMap

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)

This implementation spares its clients from the unspecified, generally chaotic ordering provided by HashMap (and Hashtable), without incurring the increased cost associated with TreeMap.

TreeMap

Implemented in Red-Black Tree;

Tuple

Defined by user:

public class Tuple<X, Y> { 
  public final X x; 
  public final Y y; 
  public Tuple(X x, Y y) { 
    this.x = x; 
    this.y = y; 
  } 
}

Pair

1
2
3

Pair<Integer, String> pair = new Pair<>(1, "One");
Integer key = pair.getKey();
String value = pair.getValue();

String

StringBuffer is thread safe while StringBuilder is not.

Reasons for Immutable

The string is Immutable in Java because String objects are cached in String pool. Since cached String literals are shared between multiple clients there is always a risk, where one client’s action would affect all another client.
Since Strings are very popular as HashMap key, it’s important for them to be immutable so that they can retrieve the value object which was stored in HashMap. Mutable String would produce two different hash-codes at the time of insertion and retrieval if contents of String was modified after insertion, potentially losing the value object in the map.

Basics

Top 25 Java Collection Framework Interview Questions Answers for Freshers and Experienced Programmers

Double

Double Comparison

double a = 1.000001;
double b = 0.000001;
double c = a-b;
if (Math.abs(c-1.0) <= 0.000001) {...}

Enhanced For Loop

Enhanced for loop makes a copy of each element in the iterative.

File/Cmd Read

public class ReadWriteFile
{ 
  public static void main(String[] args)throws Exception 
  {
    // File and BufferedReader BufferedWriter
    File file = new File(fileName); 
    BufferedReader br = new BufferedReader(new FileReader(file)); 
    String st; 
    while ((st = br.readLine()) != null) 
          System.out.println(st); 
    BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
    writer.write(str);
    writer.close();
    
    // FileReader FileWriter
    FileReader fr = new FileReader(fileName); 
    int i; 
    while ((i=fr.read()) != -1) 
      System.out.print((char) i); 
    FileWriter fileWriter = new FileWriter(fileName);
    PrintWriter printWriter = new PrintWriter(fileWriter);
    printWriter.print("Some String");
  }
}

public class JavaScannerExample
{
    public static void main (String[] args)
    {
        Scanner scanner = new Scanner(System.in);
        String username = scanner.next();
        int age = scanner.nextInt();
        String discription = scanner.nextLine();
	}
}

Override PriorityQueue Comparator

Comparator<Integer> myComoparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer i1, Integer i2) {
        if (i1 < i2) {             
            return 1;         
        } else if (i1 > i2) {
            return -1;
        } else { // ==
            return 0;
        }
    }
};
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer> (k, myComparator);

1	new PriorityQueue<Integer>(Collections.reverseOrder());

1	PriorityQueue<int[]> pq = new PriorityQueue<int[]>((a, b) -> A[a[0]] * A[b[1]] - A[a[1]] * A[b[0]]);

Override Collections Sort

Collections.sort(list, new Comparator<int[]>() {
	@Override
	public int compare(int[] o1, int[] o2) {
	return o1[0] - o2[0];
	}
});

Exception

Java Exception

Syntax

`final`

By using the final keyword when declaring a variable, the Java compiler won’t allow to change the value of that variable. Instead, it will report a compile-time error: