Category: Java Programming

Java Stream API is a powerful tool for working with collections. It provides a high-level way to process data with a functional programming style. Stream operations are performed in two stages: intermediate and terminal. Intermediate operations include filtering and mapping, while terminal operations include collecting and reducing.

Here’s an example of using streams to filter and print even numbers:

import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .forEach(System.out::println);
    }
}
            

This code filters the list for even numbers and prints them. Streams are powerful because they can process large datasets efficiently with minimal code. Additionally, streams are designed to be lazy, meaning operations are only executed when needed, which helps optimize performance.

ArrayList and LinkedList are two commonly used list implementations in Java. Both implement the List interface but differ in how they store elements. ArrayList uses a dynamic array to store elements, making it efficient for random access. In contrast, LinkedList uses a doubly-linked list, which is better suited for frequent insertions and deletions.

Here’s an example of using ArrayList and LinkedList:

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List arrayList = new ArrayList<>();
        List linkedList = new LinkedList<>();
        arrayList.add("Apple");
        linkedList.add("Banana");
    }
}
            

For applications that require quick access to elements, ArrayList is a better choice. However, LinkedList is more efficient when frequent insertions or deletions occur, especially at the beginning or middle of the list. Choosing between the two depends on the specific use case.

Annotations in Java provide metadata about code and are used by the compiler and runtime. Java offers built-in annotations like `@Override` and `@Deprecated`, and you can also create custom annotations. Annotations help simplify configuration and provide additional information to the code.

Here’s an example of using the `@Override` annotation:

class Parent {
    void display() {
        System.out.println("Parent display");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child display");
    }
}
            

The `@Override` annotation ensures that the method is overriding the parent class method. Custom annotations can be used for tasks like validation and logging. Understanding annotations improves the readability and maintainability of your code.

In Java, both interfaces and abstract classes are used to define abstract methods. However, there are key differences between them. An interface defines a contract that classes must follow, whereas an abstract class provides a partial implementation. Interfaces use the `interface` keyword, while abstract classes use the `abstract` keyword.

Here’s an example of an interface and an abstract class:

interface Animal {
    void sound();
}

abstract class Bird {
    abstract void fly();
    void eat() {
        System.out.println("Bird is eating");
    }
}
            

In this example, the interface `Animal` defines a method without implementation, while the abstract class `Bird` provides both an abstract and a concrete method. Understanding when to use an interface or an abstract class is important for designing flexible and reusable Java programs.

Exception handling in Java allows developers to manage runtime errors in a clean and controlled manner. Java provides the try-catch-finally mechanism to handle exceptions. The `try` block contains code that may throw an exception, while the `catch` block handles the exception.

Here’s an example of exception handling:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }
    }
}
            

In this example, an `ArithmeticException` is caught and handled gracefully. Java also supports custom exceptions by extending the `Exception` class. Following best practices such as catching specific exceptions and logging errors helps improve the reliability of applications.

Inheritance is a core concept of Java’s object-oriented programming. It allows one class to inherit fields and methods from another, promoting code reuse. The class that inherits is called the subclass, while the class being inherited from is the superclass.

Here’s an example of inheritance:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}
            

In this example, the `Dog` class inherits the `sound` method from the `Animal` class but overrides it to provide a more specific behavior. Inheritance helps create a hierarchical relationship between classes, enabling polymorphism and code extension.