TCS and Accenture Interview Questions Guide
Uploaded by
Kanchan Prasad kpTCS and Accenture Interview Questions Guide
Uploaded by
Kanchan Prasad kpCommon questions
Powered by AIIn Java, the stack is used for storing short-lived variables and function call tasks, while the heap is used for dynamic memory allocation and storing objects. Stack memory is faster as it stores data in a last-in, first-out manner and has a smaller memory footprint. Heap memory, being larger, accommodates more complex memory allocations but is slower due to garbage collection. This distinction affects performance, as excessive heap usage can lead to high latency from garbage collection, while stack overflows can occur from excessive recursion .
Transforming a Spring Boot application into a serverless architecture involves several steps. First, you need to identify the parts of the application that can be broken down into discrete functions that do minimal work, fitting the serverless computing model. Then, refactor the application code to fit these functions, removing dependencies on server-based features. Next, choose a serverless platform such as AWS Lambda, Azure Functions, or Google Cloud Functions, and configure your application functions to run on this platform. Finally, set up triggers, manage configuration and dependencies using environment variables or parameter stores, and ensure the application functions correctly as expected in a serverless context .
Spring Boot's Auto-Configuration works by utilizing the `@EnableAutoConfiguration` annotation, which attempts to automatically configure the beans that are present on the classpath. It uses conditional annotations such as `@ConditionalOnClass`, `@ConditionalOnBean`, among others, to check for the presence of classes and beans and conditionally apply configurations. Auto-configuration classes are usually registered in a `spring.factories` file, which tells Spring what's available on the classpath and should be configured. This mechanism enables the application to start with minimal configurations for many common integration technologies .
Migrating a Java application to a newer version can bring challenges such as compatibility issues, deprecated APIs, and changes in library behaviors or versions. These can be overcome by thoroughly testing the application under the new version, using tools to check for deprecated APIs, and updating third-party libraries to compatible versions. It's also vital to review release notes comprehensively and possibly refactor parts of the code that depend on removed features. Additionally, a careful rollback plan should be in place in case any critical issues arise during the transition .
Spring Boot uses Tomcat as the default embedded servlet container. However, it can be replaced with Jetty, Undertow, or any other servlet container by excluding the default dependency and including the appropriate starter dependency for the desired server. For instance, replacing Tomcat with Jetty can involve excluding the `spring-boot-starter-tomcat` dependency and adding `spring-boot-starter-jetty` in the `pom.xml` file for Maven projects .
The `hashCode()` and `equals()` methods play critical roles in the operation of hash-based Java Collection classes, such as `HashMap` and `HashSet`. The `hashCode()` method computes an integer hash code for objects and is used to distribute them evenly across buckets. The `equals()` method checks for the equivalence between objects. For correct behavior in collections, consistent implementations of these methods are paramount. Specifically, if two objects are equal per `equals()`, they must return the same hash code from `hashCode()`. Failure to do this can lead to incorrect behavior, such as object duplicates and look-up failures .
In Spring Boot REST applications, exceptions can be handled globally using `@ControllerAdvice` and `@ExceptionHandler` annotations. `@ControllerAdvice` is a specialization of the `@Component` annotation that allows you to define global exception handling for controllers. By using `@ExceptionHandler` within a controller annotated with `@ControllerAdvice`, you can define methods to handle specific exceptions uniformly across the whole application, thus separating error handling from business logic .
Spring Boot Actuator provides production-ready features for Spring applications, allowing for monitoring and management through HTTP endpoints. It helps in exposing operational information such as application health, metrics, info, environment settings, and more, which are crucial for monitoring microservices in a distributed system. Using the Actuator endpoints, developers can gain insights into application performance and behavior, helping in proactive maintenance and troubleshooting .
Weak and soft references in Java are types of references that help manage memory usage for caches. Soft references allow objects to be reclaimed by the garbage collector when memory is low but not before that; thus, they are useful for implementing memory-sensitive caches. Weak references, on the other hand, are weaker than soft references and eligible for garbage collection as soon as no strong references are pointing to the object, making them useful for canonicalized mappings where memory constraints are a concern .
To optimize performance in a Spring Boot application, several strategies can be employed. These include caching frequently accessed data to reduce database hits, using asynchronous processing to handle non-blocking operations, optimizing database queries, and configuring connection pooling to reduce the overhead of repeatedly opening connections. Additionally, minimizing bean initialization time by eagerly loading beans only when necessary and utilizing profiling tools to identify bottlenecks can significantly enhance application performance .
