i
10405090xyzabc
Filter interviews by
I applied via Naukri.com
Basis aptitude questions were asked
I am passionate about the industry and believe in the company's values and mission.
I admire the company's innovative approach to consulting.
I am impressed by the company's track record of success in helping clients achieve their goals.
I value the opportunity to work with a talented team of professionals.
I am excited about the potential for growth and development within the company.
Basis coding round questions were asked, linked list etc
To reverse a linked list, iterate through the list and change the direction of pointers.
Iterate through the linked list and keep track of the previous, current, and next nodes.
Update the pointers of each node to reverse the direction.
Set the head of the linked list to the last node encountered during iteration.
I appeared for an interview in Mar 2025, where I was asked the following questions.
final, finally, and finalize serve different purposes in Java: constants, cleanup, and garbage collection respectively.
final: Used to declare constants. Example: final int MAX_VALUE = 100;
finally: A block that executes after try-catch. Example: try { /* code */ } catch { /* handle */ } finally { /* cleanup */ }
finalize(): A method called by the garbage collector. Example: protected void finalize() { /* cleanup code */ ...
The Singleton pattern restricts a class to a single instance, useful for shared resources in Java.
Private constructor prevents instantiation from outside the class.
Static instance variable holds the single instance of the class.
Lazy initialization creates the instance only when needed.
Eager initialization creates the instance at class loading time.
Thread safety can be achieved using synchronized methods or blocks.
Doubl...
I appeared for an interview in Mar 2025, where I was asked the following questions.
I appeared for an interview in Mar 2025, where I was asked the following questions.
== checks reference equality; .equals() checks value equality, can be overridden for custom behavior.
== compares memory addresses: new String('hello') == new String('hello') returns false.
.equals() compares actual content: 'hello'.equals('hello') returns true.
Override equals() when logical equality is needed, e.g., in custom classes like Person.
When overriding equals(), also override hashCode() to maintain consistency ...
Lambda expressions enhance Java code readability and maintainability by simplifying syntax and promoting functional programming.
Concise Syntax: Lambda expressions reduce boilerplate code. Example: Instead of writing an anonymous class for Runnable, use () -> System.out.println("Hello").
Improved Readability: Code becomes more expressive. Example: Using lambdas with Collections: list.forEach(item -> System.out.prin...
Checked exceptions require handling; unchecked exceptions do not. Custom exceptions can be either based on the use case.
Checked exceptions must be caught or declared, e.g., IOException.
Unchecked exceptions do not require explicit handling, e.g., NullPointerException.
Checked exceptions are used for recoverable conditions, while unchecked indicate programming errors.
Custom exceptions can be created for specific applicati...
Method overloading allows same method name with different parameters; overriding changes method behavior in subclasses.
Method Overloading: Same method name, different parameters (e.g., int add(int a, int b), double add(double a, double b)).
Method Overriding: Subclass provides specific implementation of a method defined in its superclass (e.g., class Animal { void sound() {} }, class Dog extends Animal { void sound() {}...
Functional interfaces in Java enable concise implementations using lambda expressions, enhancing code readability and maintainability.
A functional interface has exactly one abstract method, e.g., Runnable (run()), Callable (call()).
Lambda expressions provide a shorthand way to implement functional interfaces, e.g., () -> System.out.println("Hello").
Functional interfaces can include multiple default or static methods...
Java Streams enable functional operations on collections with lazy evaluation, differing from Iterators in several key aspects.
Streams support functional-style operations like filter, map, and reduce, enabling concise and readable code.
Example: `List<String> filtered = list.stream().filter(s -> s.startsWith("A")).collect(Collectors.toList());`
Streams are not reusable; once a terminal operation is performed, th...
final, finally, and finalize serve different purposes in Java: constants, cleanup, and garbage collection respectively.
final: Used to declare constants. Example: final int MAX_VALUE = 100;
finally: A block that executes after try-catch. Example: try { /* code */ } catch (Exception e) { /* handle */ } finally { /* cleanup */ }
finalize(): A method called by the garbage collector. Example: protected void finalize() { /* cl...
Java annotations provide metadata for classes, enhancing code readability and maintainability, especially in frameworks like Spring.
Annotations serve as metadata, providing additional information about classes, methods, and fields.
Common built-in annotations include @Override, @Deprecated, and @SuppressWarnings.
Spring framework uses annotations like @Component and @Service for defining beans and @Autowired for dependen...
Java Streams enable parallel processing using ForkJoin framework, but have pitfalls like race conditions and performance issues with small datasets.
Use parallelStream() for parallel processing: Example: list.parallelStream().map(...).collect(Collectors.toList());
Avoid shared mutable state to prevent race conditions: Use immutable objects or thread-safe collections.
Consider the size of the dataset: Parallel streams are ...
10405090xyzabc interview questions for popular designations
I appeared for an interview in Mar 2025, where I was asked the following questions.
I appeared for an interview in Mar 2025, where I was asked the following questions.
ArrayList offers fast access and is memory efficient, while LinkedList excels in insertions and deletions.
ArrayList: O(1) access time, ideal for frequent retrievals. Example: Storing user data for quick lookups.
LinkedList: O(1) insertions/deletions at ends, suitable for dynamic data. Example: Implementing a playlist where songs can be added/removed.
Memory overhead: LinkedList has higher memory usage due to node pointer...
== checks reference equality; .equals() checks value equality. Override equals() for custom objects to ensure correct comparisons.
== compares memory addresses, while .equals() compares actual content.
Example: new String("hello") == new String("hello") returns false.
"hello".equals("hello") returns true, showing value equality.
Wrapper classes like Integer cache small values, affecting == behavior.
Override equals() when l...
Lambda expressions enhance Java code readability and maintainability by simplifying syntax and promoting functional programming.
Concise Syntax: Lambda expressions reduce boilerplate code. For example, instead of writing an anonymous class for a Runnable, you can use: `Runnable r = () -> System.out.println("Hello");`
Improved Readability: Code becomes more expressive. For instance, using `list.forEach(item -> Syste...
Checked exceptions require handling; unchecked exceptions do not. Custom exceptions can be either, based on use case.
Checked exceptions must be caught or declared (e.g., IOException, SQLException).
Unchecked exceptions do not require explicit handling (e.g., NullPointerException, ArithmeticException).
Checked exceptions promote robust error handling but can clutter code.
Unchecked exceptions indicate programming errors th...
The Java Memory Model defines thread interactions with memory, ensuring visibility and ordering in multithreaded environments.
JMM specifies how threads read and write shared variables, ensuring visibility and ordering.
Volatile keyword ensures that changes to a variable are visible to all threads immediately.
Synchronized blocks provide mutual exclusion, preventing multiple threads from accessing critical sections simult...
Method overloading allows same method name with different parameters; overriding changes parent method behavior in subclasses.
Method Overloading: Same method name, different parameters (e.g., int add(int a, int b) vs. double add(double a, double b)).
Method Overriding: Subclass provides specific implementation of a method defined in its superclass (e.g., class Dog extends Animal).
Overloading is resolved at compile time ...
Functional interfaces in Java enable lambda expressions, enhancing code conciseness and API evolution without breaking changes.
A functional interface has exactly one abstract method, e.g., Runnable, Callable.
Lambda expressions provide a concise syntax to implement functional interfaces, e.g., () -> System.out.println("Hello").
Functional interfaces can have multiple default or static methods, allowing additional func...
Java Streams enable functional operations on collections with lazy evaluation, differing from Iterators in several key aspects.
Streams support functional-style operations like filter, map, and reduce, enabling more concise and readable code.
Example: Using stream().filter(x -> x > 10) to filter elements greater than 10 from a collection.
Streams are not reusable; once a terminal operation is performed, the stream c...
Singleton pattern restricts class instantiation to one object, useful for shared resources like database connections.
Private constructor prevents instantiation from outside the class.
Static instance variable holds the single instance of the class.
Lazy initialization creates the instance only when needed.
Eager initialization creates the instance at class loading time.
Thread safety can be achieved using synchronized meth...
Java annotations provide metadata for classes, enhancing code readability and maintainability, especially in frameworks like Spring.
Annotations like @Component and @Service in Spring simplify bean management and dependency injection.
Built-in annotations such as @Override improve code clarity by indicating overridden methods.
Custom annotations can encapsulate specific behaviors, reducing repetitive code.
Annotations redu...
Java Streams enable parallel processing using ForkJoin framework, but have pitfalls like race conditions and debugging challenges.
Use parallel streams for CPU-intensive tasks to leverage multi-core processors.
Avoid using parallel streams for small datasets as overhead may outweigh benefits.
Be cautious of shared mutable state to prevent race conditions; prefer immutable data structures.
Use forEachOrdered() for order-sen...
I appeared for an interview in Mar 2025, where I was asked the following questions.
I appeared for an interview in Mar 2025, where I was asked the following questions.
I appeared for an interview in Mar 2025, where I was asked the following questions.
ArrayList uses dynamic arrays, while LinkedList uses doubly linked nodes for storage and access.
ArrayList is faster for random access due to its underlying array structure. Example: arrayList.get(index).
LinkedList is better for frequent insertions and deletions. Example: linkedList.add(index, element).
ArrayList has a fixed size, which can lead to resizing overhead. LinkedList grows dynamically.
Memory consumption differ...
== checks reference equality, while .equals() checks value equality in Java objects.
== compares memory addresses (references) of objects.
Example: String a = new String("test"); String b = new String("test"); a == b returns false.
.equals() compares the actual content of objects.
Example: a.equals(b) returns true for the same content.
Use == for primitive types (int, char, etc.) and .equals() for object comparisons.
Imprope...
Java's garbage collector automatically manages memory by reclaiming unused objects, optimizing performance and resource usage.
Java uses automatic garbage collection to manage memory, freeing developers from manual memory management.
The main garbage collection algorithms in Java include: Serial, Parallel, CMS (Concurrent Mark-Sweep), and G1 (Garbage-First).
The Serial GC is a simple, single-threaded collector suitable fo...
Java 8 introduced lambdas and the Stream API, enhancing functional programming and data processing capabilities.
Lambdas: Enable concise representation of anonymous functions. Example: (x, y) -> x + y.
Stream API: Facilitates functional-style operations on collections. Example: list.stream().filter(x -> x > 10).collect(Collectors.toList()).
Default Methods: Allow adding new methods to interfaces without breaking ...
Checked exceptions must be declared or handled; unchecked exceptions do not require explicit handling.
Checked exceptions are subclasses of Exception (excluding RuntimeException). Example: IOException.
Unchecked exceptions are subclasses of RuntimeException. Example: NullPointerException.
Checked exceptions must be either caught using try-catch or declared in the method signature with throws.
Unchecked exceptions can be ca...
The Java Memory Model defines how threads interact through memory and ensures visibility and ordering of shared variables.
The Java Memory Model (JMM) specifies how threads interact through memory, ensuring consistency and visibility.
It defines rules for visibility, atomicity, and ordering of operations in a multithreaded environment.
Synchronization mechanisms (like synchronized blocks) ensure that only one thread can a...
Method overloading allows multiple methods with the same name but different parameters; overriding redefines a method in a subclass.
Method Overloading: Same method name, different parameter types or counts.
Example of Overloading: 'void add(int a, int b)' and 'void add(double a, double b)'.
Use Overloading for convenience and readability when performing similar operations.
Method Overriding: Redefining a method in a subcl...
I appeared for an interview in Mar 2025, where I was asked the following questions.
I appeared for an interview in Mar 2025, where I was asked the following questions.
Top trending discussions
Some of the top questions asked at the 10405090xyzabc interview -
The duration of 10405090xyzabc interview process can vary, but typically it takes about 2-4 weeks to complete.
based on 1.4k interviews
Interview experience
based on 18 reviews
Rating in categories
Software Developer
16.8k
salaries
| ₹1.5 L/yr - ₹8.6 L/yr |
Software Engineer
10k
salaries
| ₹1 L/yr - ₹5.4 L/yr |
Sales Officer
416
salaries
| ₹5.7 L/yr - ₹5.7 L/yr |
Softwaretest Engineer
25
salaries
| ₹1 L/yr - ₹1.9 L/yr |
Test Engineer
12
salaries
| ₹1.8 L/yr - ₹7.3 L/yr |
Amazon
Mahindra & Mahindra
Delhivery
Siemens