Yes. In order to use a custom class for a key, it is necessary that hashCode() and equals() are implemented correctly. To put it simply, we have to ensure that the hashCode() method returns: the same value for the object as long as the state doesn't change (Internal Consistency).

<ol>
<li>It provides very high concurrency in a multi-threaded environment.</li>
<li>The read operation can be very fast when the write operation is done with a lock.</li>
<li>It provides No object-level Locking.</li>
<li>It uses a multitude of locks.</li>
<li>It allows other threads to iterate the objects when one thread is writing.</li>
<li>It is thread-safe, especially in the case of multi-threading.</li>
</ol>

In a typical design based on abstractions, we need to refactor implementers to save the design from just breaking down.

Default interface methods are an efficient way to deal with this issue. They allow us to add new methods to an interface that are automatically available in the implementations. Therefore, we don't need to modify the implementing classes.

In this way, backward compatibility is neatly preserved without having to refactor the implementers.

These are the new features in Java 8 -

<ol>
<li>Introduction of static and default - interfaces can have static and default methods that, despite being declared in an interface, have a defined behavior.</li>
<li>Introduction of Method references - In Java 8 there are 4 variants of Method references that can be used as a shorter and more readable alternative for a lambda expression which only calls an existing method.</li>
<li>Introduction of Optional<T> class - It can help to handle situations where there is a possibility of getting the NPE. It works as a container for the object of type T - no more annoying code for developers.</li>
<li>Introduction of forEach() method in Iterable interface.</li>
</ol>

No, we cannot override the static method in Java. Static methods are resolved even before objects are created, that's why it's not possible to override static methods in Java. However, it is a common mistake to confuse method overriding with method hiding.

Following steps must be taken to create an immutable class in Java -

<ol>
<li>The class must be declared as final so that child classes can’t be created.</li>
<li>Data members in the class must be declared private so that direct access is not allowed.</li>
<li>Data members in the class must be declared as final so that we can’t change the value of it after object creation.</li>
<li>A parameterized constructor should initialize all the fields performing a deep copy so that data members can’t be modified with an object reference. (Deep Copy of objects should be performed in the getter methods to return a copy rather than returning the actual object reference)</li>
</ol>