2. What is Read-Write Lock?

Does ConcurrentHashMap in Java Use The

ReadWrite Lock? ReadWrite Lock is an implementation of a lock stripping technique,
where two separate locks are used for reading and write operations. Since the read
operation doesn't modify the state of the object, it's safe to allow multiple thread access
to a shared object for reading without locking, and by splitting one lock into the read and
write lock, you can easily do that.

Java provides an implementation of a read-write lock in the form of the

ReentrantReadWritLock class in the java.util.concurrent.lock package. This is worth
looking at before you decide to write your own read-write locking implementation.

Also, the current implementation of java.util.ConcurrentHashMap doesn't use the

ReadWriteLock, instead, it divides the Map into several segments and locks them
separately using different locks. This means any given time, only a portion of the
ConcurrentHashMap is locked, instead of the whole Map. See how
ConcurrentHashMap internally works in Java for more detail.

This core Java question is also very popular on senior and more experienced level Java
interviews e.g. 4 to 6 years, where you expect the Interviewer to go into more detail, like
by asking you to provide an implementation of the read-write lock with different policies.
If you are an experienced Java programmer, consider reading Java Concurrency in
Practice to gain more confidence about multithreading and concurrency in Java.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz889yhGOti

3. How to Make an Object Immutable in Java? Why Should You Make an Object
Immutable? Well, Immutability offers several advantages including thread safety, ability
to cache and result in a more readable multithreading code. See here to learn how to
make objects Immutable. Once again, this question can also go into more detail and
depending on your answer, can bring several other questions e.g. when you mention
Spring is Immutable, be ready with some reasons on Why String is Immutable in Java.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz889zKxfVD
4. Which Design Patterns have You Used in Your Java Project?
Always expect some design patterns-related questions for the Core Java Interview of
senior developer position. It's a better strategy to mention any GOF design pattern
rather than Singleton or MVC, which almost every other Java developer uses it.

Your best bet can be a Decorator pattern or maybe a Dependency Injection Pattern,
which is quite popular in the Spring Framework. It's also good to mention only the
design patterns which you have actually used in your project and know its tradeoffs.

It's common that once you mention a particular design pattern say Factory or Abstract
Factory, Interviewer's next question would be, have you used this pattern in your
project? So be ready with proper examples and why you choose a particular pattern.
You can also see this article for more advanced design pattern questions from Java
interviews.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz889zXE0P0

5. Do you know about Open Closed Design Principle or Liskov Substitution

Principle?
Design patterns are based on object-oriented design principles, which I strongly felt
every object-oriented developer and the programmer should know, or, at least, have a
basic idea of what are these principles and how they help you to write better object-
oriented code. I

f you don't know the answer to this question, you can politely say No, as it's not
expected from you to know the answer to every question, but by answering this
question, you can make your claim stronger as many experienced developers fail to
answer basic questions like this. See Clean Code to learn more about object-oriented
and SOLID design principles.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz889zsraal

6. Which Design Pattern Will You Use to Shield Your Code From a Third Party
library Which Will Likely to be Replaced by Another in a Couple of Months?
Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-
questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz889zzPTNc
This is just one example of the scenario-based design pattern interview question. In
order to test the practical experience of Java developers with more than 5 years of
experience, companies ask this kind of question.

You can expect more real-world design problems in different formats, some with more
detailed explanations with context, or some with only intent around.

One way to shield your code from a third-party library is to code against an interface
rather than implementation and then use dependency injection to provide a particular
implementation. This kind of question is also asked quite frequently to experienced and
senior Java developers with 5 to 7 years of experience.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A09BRMI

7. How do you prevent SQL Injection in Java Code?

This question is more asked J2EE and Java EE developers than core Java developers,
but, it is still a good question to check the JDBC and Security skill of experienced Java
programmers.

You can use PreparedStatement to avoid SQL injection in Java code. Use of the
PreparedStatement for executing SQL queries not only provides better performance
but also shield your Java and J2EE application from SQL Injection attack.

On a similar note, If you are working more on Java EE or J2EE side, then you should
also be familiar with other security issues including Session Fixation attacks or Cross-
Site Scripting attacks, and how to resolve them. These are some fields and questions
where a good answer can make a lot of difference in your selection.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A0MLzvn
9) How does get method of HashMap works in Java?
Yes, this is still one of the most popular core Java questions for senior developer
interviews. You can also expect this question on a telephonic round, followed by lots of
follow-up questions as discussed in my post how does HashMap work in Java.

The short answer to this question is that HashMap is based upon hash table data
structure and uses the hashCode() method to calculate hash code to find the bucket
location on the underlying array and the equals() method to search the object in the
same bucket in case of a collision. See here to learn more about how does get()
method of HashMap works in Java.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A1EEz7G

10) Which Two Methods HashMap key Object Should Implement?

This is one of the follow-up questions I was saying about in previous questions. Since
the working of HashMap is based upon hash table data structure, any object which you
want to use as a key for HashMap or any other hash-based collection e.g. Hashtable, or
ConcurrentHashMap must implement equals() and hashCode() method.

The hashCode() is used to find the bucket location i.e. index of the underlying array
and the equals() method is used to find the right object in a linked list stored in the
bucket in case of a collision.

By the way, from Java 8, HashMap also started using a tree data structure to store the
object in case of a collision to reduce the worst-case performance of HashMap from
O(n) to O(logN). See the article for learning more about how does HashMap handless
collisions in Java.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A1LXt94

11) Why Should an Object Used As the Key should be Immutable?

This is another follow-up of previous core Java interview questions. It's good to test the
depth of technical knowledge of candidates by asking more and more questions on the
same topic. If you know about Immutability, you can answer this question by yourself.
The short answer to this question is key should be immutable so that hashCode()
method always returns the same value.

Since the hash code returned by the hashCode() method depends on the content of
the object i.e. values of member variables. If an object is mutable then those values can
change and so is the hash code. If the same object returns a different hash code once
you inserted the value in HashMap, you will end up searching in different bucket
locations and will not be able to retrieve the object.

That's why the key object should be immutable. It's not a rule enforced by the compiler
but you should take care of it as an experienced programmer. See the article for more
advanced Java Collection interview questions.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A1sZmqd

12) How does ConcurrentHashMap achieve its Scalability?

Sometimes this multithreading + collection interview question is also asked as, the
difference between ConcurrentHashMap and Hashtable in Java. The problem with
synchronized HashMap or Hashtable was that the whole Map is locked when a thread
performs any operation with Map.

The java.util.ConcurrentHashMap class solves this problem by using a lock

stripping technique, where the whole map is locked at different segments and only a
particular segment is locked during the write operation, not the whole map.

The ConcurrentHashMap also achieves its scalability by allowing lock-free reads as

read is a thread-safe operation. See here for more advanced multi-threading and
concurrency questions in Java.

Read more: https://www.java67.com/2013/07/15-advanced-core-java-interview-

questions-answers-senior-experienced-5-6-years-programmers-
developers.html#ixzz88A3IIfb9