Crack Your Next Java Interview: Essential Core Java Questions & Answers

Zero to Hero: Ace your Java interview with our comprehensive guide to Core Java questions and answers. Boost your confidence and shine in your next interview!

Introduction: Enhance your Java skills and master the core concepts that leading companies seek. Our expertly curated guide to Core Java interview questions and answers will elevate your confidence and help you ace your next interview. This story is designed to help you quickly prepare for Core Java interview questions.

Table of Contents:

1. Core Java

• Object-Oriented Programming (OOP)
• Java Collections Framework
• Multithreading and Java Concurrency
• JVM Internals
• Exception Handling
• File I/O and Serialization
• Java Classes and Objects
• Constructors
• Methods (static, non-static, overloaded, overridden)
• Instance variables and class variables
• Garbage Collection
• String
• Object Class
• Cloning
• ENUM
• Coding Interview Questions for String

Details section

Object-Oriented Programming (OOP)

What is the difference between loose coupling and tight coupling Loose coupling: Reduces dependencies between classes, making the system more flexible Tight coupling: Increases dependencies, making the system harder to maintain

What is the difference between cohesion and coupling Cohesion: Refers to how closely related the functionalities within a single module are Coupling: Refers to the degree of interdependence between modules

What is the Liskov Substitution Principle Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program

What is the difference between an abstract class and an interface in Java Abstract class: Can have both abstract and concrete methods; supports single inheritance Interface: Only abstract methods (until Java 8); supports multiple inheritance

What is the difference between composition, aggregation, and association Composition: Strong ownership (part cannot exist without whole) Aggregation: Weak ownership (part can exist independently) Association: General relationship between objects

What is the difference between static and dynamic polymorphism Static polymorphism: Method overloading, resolved at compile-time Dynamic polymorphism: Method overriding, resolved at runtime

Method overloading vs. method overriding vs. method hiding Overloading: Same method name, different parameters Overriding: Subclass provides a specific implementation of a method already defined in the superclass Method hiding: Static methods are hidden, not overridden

Can private or static methods be overridden in Java Private methods cannot be overridden Static methods are hidden, not overridden

Can the main() method be overloaded Yes, the main() method can be overloaded with different parameter lists

Can an abstract class have a main() method Yes, an abstract class can have a main() method

Java Collections Framework

What is the difference between List, Set, and Map in Java List: Ordered, allows duplicates Set: Unordered, no duplicates Map: Key-value pairs, keys are unique

What is the difference between synchronized and concurrent collections in Java Synchronized collections: Thread-safe, uses locks Concurrent collections: Optimized for concurrent access, avoids locks when possible

How does the get method of HashMap work in Java It calculates the hash code, locates the bucket, and iterates through the linked list or tree nodes

When should you use LinkedList over ArrayList in Java Use LinkedList for frequent insertions/deletions; ArrayList for random access

What is the internal working of HashMap HashMap uses an array of linked lists or trees. Hash code determines the bucket, and keys are compared to find the value

What is CopyOnWriteArrayList and when can we use it A thread-safe variant of ArrayList, used when frequent read operations are needed with minimal write operations

Array vs. ArrayList Array: Fixed size, can hold primitives and objects ArrayList: Dynamic size, holds objects only

What is ConcurrentModificationException Thrown when a collection is modified while iterating over it using a fail-fast iterator

Why does HashMap contain a null key HashMap allows one null key, stored in the first bucket

Why override equals() and hashCode() methods To ensure consistent behavior when objects are used as keys in collections like HashMap

Multithreading and Java Concurrency

What is the difference between a process and a thread Process: Independent program execution with its own memory space Thread: A smaller unit of execution within a process, sharing memory with other threads

How can you create a thread instance and run it By implementing Runnable or extending Thread and calling the start() method

What is the difference between the Runnable and Callable interfaces Runnable: Returns void, cannot throw checked exceptions Callable: Returns a result, can throw checked exceptions

What is the purpose of the synchronized keyword To prevent concurrent access to critical sections of code, ensuring thread safety

Can a class have both synchronized and non-synchronized methods Yes, and multiple threads can execute non-synchronized methods simultaneously

What is Deadlock A situation where two or more threads are blocked forever, waiting for each other

What is Race Condition A situation where the outcome of a program depends on the relative timing of threads

JVM Internals

What is the JVM (Java Virtual Machine) An abstract computing machine that enables a computer to run Java programs

What is the difference between the Stack and the Heap Stack: Stores local variables and function calls Heap: Stores objects and their associated data

What is Garbage Collection The process of automatically reclaiming memory by deleting unused objects

What is the Metaspace A memory space that stores class metadata in Java 8 and later, replacing the PermGen

How does the JVM handle OutOfMemoryError Throws an OutOfMemoryError when JVM cannot allocate memory

Exception Handling

What is the difference between try, catch, and finally blocks try: Encloses code that might throw an exception catch: Handles the exception finally: Executes code regardless of an exception, usually for cleanup

What is the difference between checked and unchecked exceptions Checked: Must be declared or handled (IOException) Unchecked: Not required to be declared or handled (NullPointerException)

What is the difference between throw and throws throw: Used to explicitly throw an exception throws: Declares that a method can throw exceptions

What are the best practices for exception handling Use specific exceptions, avoid catching top-level exceptions, and log exceptions with meaningful messages

File I/O

What is the difference between FileInputStream and FileReader FileInputStream: For reading binary data FileReader: For reading character data

How do you read a file line by line in Java Using BufferedReader.readLine()

How do you write to a file in Java using the FileWriter class By creating an instance of FileWriter and using its write() method

What is the difference between the File and Path classes in Java File: Represents a file or directory path as a string Path: Part of NIO, representing a file path in a more flexible and efficient way

Serialization

What is the purpose of the Serializable interface in Java Marks a class for serialization, allowing its objects to be converted to a byte stream

What is the purpose of the transient keyword in Java serialization Prevents serialization of certain fields

How do you handle serialization versioning in Java By using serialVersionUID to maintain version consistency

Is it possible to serialize a class if its superclass is not serializable Yes, but only the subclass fields will be serialized

Java Classes and Objects

What is the difference between a class and an object in Java Class: A blueprint for objects Object: An instance of a class

What is the purpose of the this keyword in Java Refers to the current instance of a class

What is the difference between static and non-static methods in Java Static: Belongs to the class, called without creating an object Non-static: Belongs to an object, requires an instance to be called

What is the difference between instance variables and class variables in Java Instance variables: Belong to an object, different for each instance Class variables: Defined with static, shared among all instances

Garbage Collection

What is garbage collection in Java Garbage collection is the process by which the JVM automatically identifies and reclaims memory occupied by objects that are no longer in use, preventing memory leaks and optimizing the use of memory

How does the garbage collector work in Java The garbage collector in Java works by tracking object references and identifying objects that are no longer reachable. When an object is no longer referenced by any active part of the program, it becomes eligible for garbage collection. The garbage collector periodically scans the heap, marking and sweeping unused objects to free up memory

What is the purpose of the finalize() method in Java The finalize() method is invoked by the garbage collector before an object is destroyed. It was intended for cleanup operations, but its use is generally discouraged because it is unpredictable, can lead to performance issues, and is considered deprecated in modern Java versions

Can you request garbage collection in Java You can suggest garbage collection by calling System.gc() or Runtime.getRuntime().gc(), but you cannot force it. The JVM makes the final decision on when to run the garbage collector based on its own heuristics and optimizations

How does the garbage collector handle circular references in Java The garbage collector handles circular references by using algorithms like Mark-and-Sweep, which identify objects that are no longer reachable from any root references, regardless of whether they reference each other

Types of garbage collectors Java provides several types of garbage collectors, including:

• Serial GC: A simple, single-threaded collector suitable for small applications
• Parallel GC: A multi-threaded collector designed for throughput
• CMS (Concurrent Mark-Sweep) GC: A low-latency collector that works concurrently with the application
• G1 (Garbage-First) GC: A balanced collector aimed at reducing pauses and managing large heaps efficiently
• ZGC: A scalable low-latency collector designed for large heaps
• Shenandoah GC: Another low-pause-time collector that operates concurrently
• What is the G1 garbage collector The G1 (Garbage-First) garbage collector is designed for applications that require predictable pause times. It divides the heap into regions and prioritizes the regions with the most garbage to collect first, balancing between throughput and pause time

String

What is SCP (String Constant Pool) and its advantage The String Constant Pool (SCP) is a special memory region where Java stores string literals. The advantage of SCP is that it reduces memory usage by reusing immutable string objects instead of creating new ones each time a string literal is used

String vs. StringBuffer vs. StringBuilder

• String: Immutable sequence of characters
• StringBuffer: Mutable and thread-safe sequence of characters, synchronized methods
• StringBuilder: Mutable and not thread-safe, faster than StringBuffer in single-threaded contexts

How many objects will be created in the following code String s1 = "Boss"; Only one object is created in the String Constant Pool if "Boss" has not been created before. If it already exists, no new object is created

What is the difference between the equals() method and the == operator

• equals(): Compares the content of two objects
• ==: Compares the reference (memory address) of two objects

Is the String class final Yes, the String class is final to prevent modification of its immutable behavior

What is the intern() method in the String class The intern() method returns a canonical representation of the string. If the string is already in the String Constant Pool, intern() returns a reference to it; otherwise, it adds the string to the pool and returns the reference

Why are strings immutable in Java Strings are immutable to ensure security, performance, and thread safety. Once a String object is created, its value cannot be changed, which allows it to be shared freely without synchronization concerns

How does intern() work The intern() method checks if the string already exists in the String Constant Pool. If it does, it returns the existing string reference. If it doesn’t, it adds the string to the pool and then returns the reference

How many objects are created in Strings using string literals and the new operator

• String literals: One object is created if the string doesn’t already exist in the String Constant Pool
• new operator: Creates a new String object on the heap, regardless of the string's presence in the String Constant Pool

How does the String constant pool work The String constant pool stores string literals. When a string literal is used, Java checks the pool for an existing instance. If it exists, the reference is returned; if not, a new string is added to the pool

Difference between equals() and == operator

• equals(): Compares the actual content or value of two strings
• ==: Compares memory references, checking if two variables point to the same object in memory

Difference between String, StringBuffer, and StringBuilder

• String: Immutable, each modification creates a new object
• StringBuffer: Mutable, thread-safe with synchronized methods, used when multiple threads are involved
• StringBuilder: Mutable, not thread-safe, faster than StringBuffer, used in single-threaded environments

Important Links for Interview Preparation

1. For a detailed list of interview questions covering the entire Java stack, including Spring Boot, Java 8, and Core Java, follow this URL for comprehensive interview preparation:

This question bank will help both freshers and experienced candidates.

2- Explore solving real-time queries using Java 8 features, with a focus on a School and Teacher example