Java, spring boot

Accenture interview 4Yrs experience— Java, Spring boot, Micro services, Kafka

My recent interview experience at Accenture served as a testament to this dynamic landscape, where expertise in Java, Spring Boot, Micro services, and Kafka emerged as pivotal factors. Spring Boot, Kafka and Micro services are indeed hot trends in the market for good reason.

In this article, I share insights gleaned from navigating the interview process, offering a glimpse into the challenges and opportunities encountered along the way. From the initial screening to the final rounds of technical and behavioral assessments, each step provided valuable lessons and reflections. Join me as I delve into the intricacies of preparing for and excelling in a tech-focused interview at one of the industry’s leading firms, shedding light on the skills and strategies essential for success in today’s competitive tech landscape.

Initial Screening:

I did Apply the job in Naukri.com for the skill set of java, spring boot, Micro service and kafka. Received call after 2 days. Interview was set up on weekend.

Interview Process : 2 technical rounds.

In my interview journey with Accenture, the initial round felt comfortably manageable, with questions aligning well with my preparedness. However, as I progressed to the second round, the challenges intensified, presenting tougher technical inquiries and requiring deeper insights into Java, Spring Boot, Micro services, and Kafka.

Here is part 1 of 1st round.

1. What are the main features of java ?

Java, renowned for its versatility and reliability, offers a myriad of features that have solidified its status as one of the most widely-used programming languages. Here are some of its key features:

1. Platform Independence: Java programs are compiled into bytecode, which can run on any platform with a Java Virtual Machine (JVM), making Java applications platform-independent.
2. Object-Oriented: Java is object-oriented, allowing developers to create modular, reusable code through encapsulation, inheritance, and polymorphism.
3. Robustness: Java’s strong memory management, exception handling, and garbage collection contribute to its robustness, minimizing the risk of errors and crashes.
4. Portability: Java’s “Write Once, Run Anywhere” (WORA) philosophy enables developers to write code on one platform and execute it on any other platform with a JVM.
5. Multithreading: Java supports multithreading, allowing concurrent execution of multiple threads within a single program, enhancing performance and responsiveness.
6. Rich Standard Library: Java comes with a comprehensive standard library (Java API) that provides ready-to-use classes and methods for common tasks, such as I/O operations, networking, and data manipulation.
7. Security: Java’s built-in security features, such as bytecode verification and the security manager, help protect systems from malicious attacks and ensure safe execution of code.
8. High Performance: While initially criticized for its performance compared to natively compiled languages, Java has evolved to offer high performance through advancements in JIT (Just-In-Time) compilation and optimization techniques.
9. Dynamic: Java supports dynamic loading of classes and dynamic memory allocation, allowing applications to adapt to changing runtime conditions.
10. Community Support: Java boasts a large and active community of developers, providing access to a wealth of resources, libraries, frameworks, and tools to support development across various domains and industries.

2. What are the differences between == and .equals() in Java?

In Java, both == and .equals() are used for comparison, but they serve different purposes:

1. == (Equality Operator):

• The == operator is used to compare the references of two objects in memory. It checks if two object references point to the same memory location.
• For primitive data types (int, double, etc.), == compares the actual values.
• When used with objects, == checks if the two object references refer to the same object in memory, not necessarily if their contents are equal

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");

System.out.println(str1 == str2); // true (references point to the same memory location)
System.out.println(str1 == str3); // false (references point to different memory locations)

2 .equals()

• The .equals() method is a method defined in the Object class and is overridden by classes that want to provide their own implementation of equality comparison.
• By default, .equals() checks for object reference equality, similar to ==. However, many classes override this method to compare the contents (values) of the objects instead.
• It is important to note that some classes, like String, Integer, etc., override the .equals() method to compare their content rather than their references.

String str1 = "hello";
String str2 = "hello";
String str3 = new String("hello");

System.out.println(str1.equals(str2)); // true (contents are equal)
System.out.println(str1.equals(str3)); // true (contents are equal)

3. Where do you generally use comparable and where do you use comparator in java

In Java, Comparable and Comparator are interfaces used for sorting objects

1. Comparable Interface:

• The Comparable interface is implemented by a class to define a natural ordering for its objects.
• The natural ordering defined by Comparable is typically based on some intrinsic property of the object, such as its numeric value, alphabetical order, or date/time.
• Objects that implement Comparable can be compared to each other using the compareTo() method, which returns a negative integer, zero, or a positive integer depending on whether the current object is less than, equal to, or greater than the specified object.
• Usage — Sorts students based on their IDs

List<Student> students = new ArrayList<>();
// Add some students to the list
Collections.sort(students); // Sorts students based on their IDs

Implementation

public class Student implements Comparable<Student> {
    private int id;
    private String name;

    // Constructor, getters, setters

    @Override
    public int compareTo(Student other) {
        return this.id - other.id;
    }
}

2. Comparator Interface:

• The Comparator interface is used to define custom comparison logic for sorting objects that do not implement Comparable or when the natural ordering defined by Comparable is not suitable.
• Objects can be sorted using a specific Comparator implementation provided to sorting methods like Collections.sort() or Arrays.sort().
• Comparator defines a single method, compare(), which compares two objects and returns a negative integer, zero, or a positive integer based on the comparison result.
• Usage: Now rather than sorting based on id, you want to sort based on names

List<Student> students = new ArrayList<>();
// Add some students to the list
Collections.sort(students, new StudentComparator());

public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.getName().compareTo(s2.getName());
    }
}