DEV Community: Abhishek Singh

Database Integration with Spring Boot : Best Practices and Tools

Abhishek Singh — Sun, 23 Jun 2024 14:19:24 +0000

Integrating a database with a Spring Boot application is a common task that many developers do. Spring Boot, combined with Spring Data JPA, provides a robust framework for working with relational databases like MySQL. Additionally, tools like Flyway and Liquibase help manage database migrations efficiently. This blog will cover best practices for using Spring Data JPA with relational databases, integrating with MySQL, and managing database migrations with Flyway or Liquibase

Using Spring Data JPA with Relational Databases
Spring Data JPA simplifies the implementation of data access layers by reducing the amount of boilerplate code. It provides a powerful repository abstraction for various data stores, making database interactions more straightforward

Best Practices for Using Spring Data JPA :

Integrating with SQL Databases like MySQL :
MySQL is one of the most popular relational databases, and integrating it with Spring Boot is straightforward.

Steps to Integrate MySQL with Spring Boot :
Add Dependencies: Add the necessary dependencies for Spring Data JPA and MySQL connector in your pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

Database Configuration : Configure the database connection details in application.properties or application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: root
    password: rootpassword
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Define Your Entities : Start by defining your JPA entities Each entity represents a table in the database

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(unique = true, nullable = false)
    private String email;

    // Getters and Setters
}

Create Repositories : Create repository interfaces to perform CRUD operations. Extend JpaRepository to leverage built-in methods and custom query methods

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

Create Service Layer: Use a service layer to encapsulate business logic and interact with the repository

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // Create operation
    public User createUser(User user) {
        // Perform validation or business logic if needed
        return userRepository.save(user);
    }

    // Read operations

    public Optional<User> findUserById(Long id) {
        return userRepository.findById(id);
    }

    public Optional<User> findUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    // Update operation
    public User updateUser(Long id, User userDetails) {
        // Ensure the user exists
        User existingUser = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found with id: " + id));

        // Update user details
        existingUser.setName(userDetails.getName());
        existingUser.setEmail(userDetails.getEmail());

        // Save updated user
        return userRepository.save(existingUser);
    }

    // Delete operation
    public void deleteUser(Long id) {
        // Ensure the user exists
        User existingUser = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found with id: " + id));

        // Delete user
        userRepository.delete(existingUser);
    }
}

Exception Handling :
In the updateUser and deleteUser methods, you may want to handle cases where the user with the specified ID doesn't exist. You can create a custom exception (e.g., ResourceNotFoundException) and throw it if necessary

@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

Run MySQL Server : Ensure that the MySQL server is running, and the specified database (mydatabase) exists. You can create the database using MySQL CLI or a GUI tool like MySQL Workbench

Test the Connection : Run your Spring Boot application to verify the connection to the MySQL database. If configured correctly, Spring Boot will automatically create the necessary tables based on your entities

Database Migration with Flyway or Liquibase :
Managing database schema changes is essential for maintaining the integrity and consistency of your application. Flyway and Liquibase are two popular tools for handling database migrations.

Using Flyway for Database Migrations
Flyway is a migration tool that uses SQL scripts to manage database versioning

Add Dependencies : Add Flyway dependencies to your pom.xml

<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>

Configure Flyway : Configure Flyway in application.properties or application.yml

spring:
  flyway:
    enabled: true
    locations: classpath:db/migration

Create Migration Scripts : Place your SQL migration scripts in the src/main/resources/db/migration directory. Name the scripts following Flyway's naming convention (V1_Initial_Setup.sql, V2_Add_User_Table.sql, etc.)

-- V1__Initial_Setup.sql
CREATE TABLE user (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE
);

Run Migrations : Flyway will automatically run the migrations on application startup

Using Liquibase for Database Migrations :
Liquibase is another powerful tool for managing database migrations, supporting XML, YAML, JSON, and SQL formats.

Add Dependencies : Add Liquibase dependencies to your pom.xml

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
</dependency>

Configure Liquibase : Configure Liquibase in application.properties or application.yml

spring:
  liquibase:
    enabled: true
    change-log: classpath:db/changelog/db.changelog-master.yaml

Create ChangeLog Files : Define your database changes in src/main/resources/db/changelog. Create a master changelog file (db.changelog-master.yaml) that includes other changelog files

databaseChangeLog:
  - changeSet:
      id: 1
      author: yourname
      changes:
        - createTable:
            tableName: user
            columns:
              - column:
                  name: id
                  type: BIGINT
                  autoIncrement: true
                  constraints:
                    primaryKey: true
              - column:
                  name: name
                  type: VARCHAR(100)
                  constraints:
                    nullable: false
              - column:
                  name: email
                  type: VARCHAR(100)
                  constraints:
                    nullable: false
                    unique: true

Run Migrations : Liquibase will automatically run the migrations on application startup

Conclusion
Integrating databases with Spring Boot is seamless, thanks to Spring Data JPA, and tools like Flyway and Liquibase make managing database migrations straightforward. By following the best practices outlined in this blog, you can ensure your Spring Boot application interacts efficiently with relational databases like MySQL, and your database schema evolves smoothly as your application grows

Spring Boot Testing Best Practices

Abhishek Singh — Sun, 23 Jun 2024 13:48:21 +0000

Testing is a crucial aspect of software development, ensuring that your application behaves as expected and is free from bugs. Spring Boot provides excellent support for testing, making it easier to write unit tests, integration tests, and test RESTful services. In this blog, we will explore best practices for testing Spring Boot applications, covering unit testing, integration testing, and using MockMvc for testing RESTful services

Writing Unit Tests for Spring Boot Applications
Unit tests are the foundation of a solid test suite. They focus on testing individual components in isolation, such as methods or classes, without depending on external systems like databases or web servers

Best Practices for Unit Testing:

Use JUnit 5: JUnit 5 is the latest version of the popular testing framework and provides powerful features for writing tests. Ensure you include the necessary dependencies in your pom.xml or build.gradle file


<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.1</version>
    <scope>test</scope>
</dependency>

Mock Dependencies: Use mocking frameworks like Mockito to mock dependencies and focus on testing the logic of the class under test

@SpringBootTest
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void testFindUserById() {
        User user = new User(1L, "John");    

when(userRepository.findById(1L)).thenReturn(Optional.of(user));

        User result = userService.findUserById(1L);

        assertEquals("John", result.getName());
    }
}

Test Boundary Conditions: Ensure you test edge cases, null values, and invalid inputs to make your tests comprehensive

Write Fast and Isolated Tests: Unit tests should run quickly and independently. Avoid using external resources like databases or file systems

Use Test Doubles for Dependencies: When necessary, create stub or mock implementations for dependencies that your class under test interacts with. This helps isolate the component being tested

@Test
void testUserCreation() {
    User user = new User(null, "Jane");
    when(userRepository.save(any(User.class))).thenReturn(new User(1L, "Jane"));

    User createdUser = userService.createUser(user);

    assertNotNull(createdUser.getId());
    assertEquals("Jane", createdUser.getName());
}

Integration Testing with Spring Boot :
Integration tests verify that different parts of the application work together as expected. They test the application’s behavior in a realistic environment, including interactions with databases, web servers, and other systems

Best Practices for Integration Testing :

Use @SpringBootTest: The @SpringBootTest annotation loads the full application context and is useful for writing integration tests

@SpringBootTest
@ExtendWith(SpringExtension.class)
public class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Autowired
    private UserRepository userRepository;

    @Test
    void testFindUserById() {
        User user = new User(1L, "John");
        userRepository.save(user);
        User result = userService.findUserById(1L);
        assertEquals("John", result.getName());
    }
}

Use @Transactional for Database Tests: Use the @Transactional annotation to ensure that database changes are rolled back after each test, maintaining a clean state

@SpringBootTest
@Transactional
public class UserServiceIntegrationTest {
    // Integration tests
}

Profile-Specific Configuration: Use different application properties for testing to avoid conflicts with development or production environments

# src/test/resources/application-test.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: password

Test Slices: Use test slices like @WebMvcTest, @DataJpaTest, @RestClientTest to load only the necessary parts of the application context, making tests faster and more focused

@DataJpaTest
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    void testSaveUser() {
        User user = new User(null, "Alice");
        User savedUser = userRepository.save(user);
        assertNotNull(savedUser.getId());
        assertEquals("Alice", savedUser.getName());
    }
}

Using MockMvc for Testing RESTful Services
MockMvc is a powerful tool for testing Spring MVC controllers. It allows you to perform HTTP requests and assert responses without starting the entire web server

Best Practices for Using MockMvc

Setup MockMvc with @WebMvcTest: Use the @WebMvcTest annotation to test only the web layer and configure MockMvc

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void testGetUserById() throws Exception {
        User user = new User(1L, "John");
        when(userService.findUserById(1L)).thenReturn(user);

        mockMvc.perform(get("/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("John"));
    }
}

Test Different Scenarios: Ensure you test various scenarios, including success, failure, and edge cases

@Test
void testGetUserById_NotFound() throws Exception {
    when(userService.findUserById(1L)).thenThrow(new UserNotFoundException());

    mockMvc.perform(get("/users/1"))
           .andExpect(status().isNotFound());
}

Use JSONPath for Response Assertions: Use JSONPath expressions to assert specific parts of the JSON response.

mockMvc.perform(get("/users/1"))
       .andExpect(status().isOk())
       .andExpect(jsonPath("$.id").value(1))
       .andExpect(jsonPath("$.name").value("John"));

Verify Interactions: Use Mockito to verify that service methods are called as expected.

verify(userService).findUserById(1L);

Test with Different HTTP Methods: Test various HTTP methods (GET, POST, PUT, DELETE) to ensure your RESTful services handle them correctly

@Test
void testCreateUser() throws Exception {
    User user = new User(null, "Jane");
    when(userService.createUser(any(User.class))).thenReturn(new User(1L, "Jane"));

    mockMvc.perform(post("/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content("{\"name\": \"Jane\"}"))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.name").value("Jane"));
}

Test Error Handling: Ensure your tests cover error scenarios and that your application returns appropriate error responses

@Test
void testCreateUser_InvalidInput() throws Exception {
    mockMvc.perform(post("/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content("{\"name\": \"\"}"))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors").isNotEmpty());
}

Conclusion
Testing is a vital part of developing reliable and maintainable Spring Boot applications. By following these best practices for unit testing, integration testing, and using MockMvc, you can ensure that your application is robust and behaves as expected. Remember to write tests that are fast, isolated, and comprehensive to cover various scenarios and edge cases

Happy testing!

SQL VS NoSQL

Abhishek Singh — Mon, 10 Jun 2024 14:49:01 +0000

Choosing Between SQL and NoSQL Databases: A Comprehensive Guide

The decision to use SQL (Structured Query Language) or NoSQL (Not Only SQL) databases depends on various factors such as the nature of the data, scalability requirements, and the specific needs of your application. Here are some guidelines to consider

Data Structure and Schema Flexibility:

Use SQL databases when you have a structured data model with a fixed schema. SQL databases enforce a schema, which ensures data consistency and integrity.
Use NoSQL databases when you have unstructured or semi-structured data, or when your data model is expected to evolve frequently. NoSQL databases offer schema flexibility, allowing you to store and retrieve data without a predefined schema.

Scaling:

Use NoSQL databases for horizontal scalability. They are designed to scale out across multiple servers or clusters, making them suitable for handling large volumes of data and high write loads.
SQL databases can also scale vertically (by increasing server capacity) but may face limitations in horizontal scaling due to the rigid structure enforced by the relational model.

Complex Queries and Transactions:

Use SQL databases when your application requires complex queries involving multiple tables, joins, and aggregations. SQL databases excel at handling complex relational queries.
NoSQL databases may not be as suitable for complex queries involving multiple entities or relationships. They typically prioritize fast data retrieval and simple queries over complex relational operations.

ACID Compliance:

Use SQL databases when your application requires ACID (Atomicity, Consistency, Isolation, Durability) compliance for transactions. SQL databases provide strong consistency guarantees and ensure data integrity.
NoSQL databases often sacrifice strong consistency for performance and scalability. They may offer eventual consistency or relaxed transaction guarantees, which might be acceptable depending on your application's requirements.

Data Volume and Speed:

Use NoSQL databases when dealing with large volumes of rapidly changing data, such as in real-time analytics, IoT (Internet of Things) applications, or social media platforms.
SQL databases are suitable for applications with structured data and moderate to high transactional requirements, such as e-commerce platforms, financial systems, and enterprise applications.

Development and Deployment Flexibility:

NoSQL databases are often favored for agile development and rapid iteration, as they offer more flexibility in data modeling and schema evolution.
SQL databases may require more upfront planning and schema design but can offer better tooling, mature ecosystems, and robust transactional support for enterprise applications.

Ultimately, the choice between SQL and NoSQL databases depends on your specific use case, performance requirements, scalability needs, and development preferences. In some cases, a combination of both types of databases (polyglot persistence) might be appropriate, leveraging the strengths of each for different parts of your application.

Keep Reading...

Java 8 Lambda Expressions and Functional Interfaces

Abhishek Singh — Sun, 09 Jun 2024 14:01:39 +0000

Overview :

Java 8 introduced Lambda Expressions and Functional Interfaces, which bring functional programming capabilities to Java. These features allow for more concise and readable code, especially when working with collections and performing common tasks like filtering, mapping, and reducing

By the end of this blog, we will understand:

What Lambda Expressions are?
What Functional Interfaces are?
How to create and use Lambda Expressions?
Common use cases for Lambda Expressions and Functional Interfaces

What are Lambda Expressions?
Lambda Expressions are a way to provide clear and concise syntax for writing anonymous methods (functions). They enable you to treat functionality as a method argument, or pass a block of code around as data

Syntax of Lambda Expressions :
The basic syntax of a lambda expression is:

(parameters) -> expression
or
(parameters) -> { statements; }

Example: Simple Lambda Expression

// Traditional way using an anonymous class
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, world!");
    }
};

// Using a lambda expression
Runnable lambdaRunnable = () -> System.out.println("Hello, world!");

What are Functional Interfaces?
A Functional Interface is an interface with a single abstract method. They can have multiple default or static methods but only one abstract method. Lambda expressions can be used to instantiate functional interfaces.

Example: Defining a Functional Interface

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();
}

Java 8 includes several built-in functional interfaces in the java.util.function package, such as Predicate, Function, Consumer, and Supplier.

Creating and Using Lambda Expressions :

Example 1: Using Predicate Interface
The Predicate interface represents a boolean-valued function of one argument.

import java.util.function.Predicate;

public class Main {
    public static void main(String[] args) {
        Predicate<String> isEmpty = (str) -> str.isEmpty();

        System.out.println(isEmpty.test("")); // Output: true
        System.out.println(isEmpty.test("Hello")); // Output: false
    }
}

Example 2: Using Function Interface
The Function interface represents a function that takes one argument and produces a result.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, String> intToString = (num) -> "Number: " + num;

        System.out.println(intToString.apply(5)); // Output: Number: 5
    }
}

Example 3: Using Consumer Interface
The Consumer interface represents an operation that takes a single argument and returns no result.

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<String> printUpperCase = (str) -> System.out.println(str.toUpperCase());

        printUpperCase.accept("hello"); // Output: HELLO
    }
}

Example 4: Using Supplier Interface
The Supplier interface represents a supplier of results, which doesn't take any arguments and returns a result.
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Supplier<String> helloSupplier = () -> "Hello, world!";

        System.out.println(helloSupplier.get()); // Output: Hello, world!
    }
}

Common Use Cases for Lambda Expressions and Functional Interfaces :

Use Case 1: Filtering Collections

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Filter names that start with 'A'
        List<String> filteredNames = names.stream()
          .filter(name -> name.startsWith("A"))
              .collect(Collectors.toList());

        filteredNames.forEach(System.out::println);             // Output: Alice
    }
}

Use Case 2: Mapping Collections

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Convert names to uppercase
        List<String> upperCaseNames = names.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());

        upperCaseNames.forEach(System.out::println); // Output: ALICE, BOB, CHARLIE, DAVID
    }
}

Use Case 3: Reducing Collections

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Sum of all numbers
        int sum = numbers.stream()
                         .reduce(0, Integer::sum);

        System.out.println("Sum: " + sum); // Output: Sum: 15
    }
}

Use Case 4: Creating Custom Functional Interfaces

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class Main {
    public static void main(String[] args) {
        // Define lambda expressions for addition and multiplication
        MathOperation addition = (a, b) -> a + b;
        MathOperation multiplication = (a, b) -> a * b;

        System.out.println("Addition: " + addition.operate(5, 3)); // Output: Addition: 8
        System.out.println("Multiplication: " + multiplication.operate(5, 3)); // Output: Multiplication: 15
    }
}

Summary
Lambda Expressions and Functional Interfaces are powerful features in Java 8 that enable you to write more concise, readable, and functional-style code. They are particularly useful for operations on collections and data, allowing you to:

Filter: Select elements based on a condition.
Map: Transform elements.
Reduce: Combine elements into a single result.
Custom Functional Interfaces: Define your own interfaces for specific tasks

Happy Coding...

Java Stream API

Abhishek Singh — Sun, 09 Jun 2024 13:37:34 +0000

Overview :
The Java Stream API facilitates processing sequences of elements, offering operations like filtering, mapping, and reducing. Streams can be used to perform operations in a declarative way, resembling SQL-like operations on data

Key Concepts :
Stream: A sequence of elements supporting sequential and parallel aggregate operations

Intermediate Operations: Operations that return another stream and are lazy (e.g., filter, map)

Terminal Operations: Operations that produce a result or a side-effect and are not lazy (e.g., collect, forEach)

Example Scenario :
Suppose we have a list of Person objects and we want to perform various operations on this list using the Stream API

public class Person {
    private String name;
    private int age;
    private String city;

    public Person(String name, int age, String city) {
        this.name = name;
        this.age = age;
        this.city = city;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + ", city='" + city + "'}";
    }
}

Use Cases :

Filtering
Mapping
Collecting
Reducing
FlatMapping
Sorting
Finding and Matching
Statistics

Filtering : Filtering allows you to select elements that match a given condition

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );

        // Filter people older than 25
        List<Person> filteredPeople = people.stream().filter(person -> person.getAge() > 25)                                       .collect(Collectors.toList());
        filteredPeople.forEach(System.out::println);
    }
}

Mapping : Mapping transforms each element to another form using a function

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );
        // Get list of names
        List<String> names = people.stream()
                                   .map(Person::getName)
                                   .collect(Collectors.toList());
        names.forEach(System.out::println);
    }
}

Collecting : Collecting gathers the elements of a stream into a collection or other data structures

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );
        // Collect names into a set
        Set<String> uniqueCities = people.stream()
         .map(Person::getCity).collect(Collectors.toSet());
        uniqueCities.forEach(System.out::println);
    }
}

Reducing : Reducing performs a reduction on the elements of the stream using an associative accumulation function and returns an Optional

public class Main {
    public static void main(String[] args) {
         List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );
        // Sum of ages
        int totalAge = people.stream()
                 .map(Person::getAge).reduce(0, Integer::sum);
        System.out.println("Total Age: " + totalAge);
    }
}

FlatMapping : FlatMapping flattens nested structures into a single stream.

public class Main {
    public static void main(String[] args) {
        List<List<String>> namesNested = Arrays.asList(
            Arrays.asList("John", "Doe"),
            Arrays.asList("Jane", "Smith"),
            Arrays.asList("Peter", "Parker")
        );

        List<String> namesFlat = namesNested.stream()
             .flatMap(List::stream).collect(Collectors.toList());
        namesFlat.forEach(System.out::println);
    }
}

Sorting : Sorting allows you to sort the elements of a stream

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );

        // Sort by age
        List<Person> sortedPeople = people.stream()
            .sorted(Comparator.comparing(Person::getAge))
            .collect(Collectors.toList());
        sortedPeople.forEach(System.out::println);
    }
}

Finding and Matching :
Finding and matching operations check the elements of a stream to see if they match a given predicate

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );

        // Find any person living in New York
        Optional<Person> personInNY = people.stream()
               .filter(person -> "NewYork".equals(person.getCity())).findAny();

        personInNY.ifPresent(System.out::println);

        // Check if all people are older than 18
        boolean allAdults = people.stream()
          .allMatch(person -> person.getAge() > 18);

        System.out.println("All adults: " + allAdults);
    }
}

Statistics : The Stream API can also be used to perform various statistical operations like counting, averaging, etc.

public class Main {
    public static void main(String[] args) {
       List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );

        // Count number of people
        long count = people.stream().count();
        System.out.println("Number of people: " + count);

        // Calculate average age
        Double averageAge = people.stream()
        .collect(Collectors.averagingInt(Person::getAge));

        System.out.println("Average Age: " + averageAge);
    }
}

Practical Example :
Here's a comprehensive example that uses several of the features mentioned above:

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30, "New York"),
            new Person("Bob", 20, "Los Angeles"),
            new Person("Charlie", 25, "New York"),
            new Person("David", 40, "Chicago")
        );

        // Filter, map, sort, and collect
        List<String> names = people.stream()
                                   .filter(person -> person.getAge() > 20)
                                   .map(Person::getName)
                                   .sorted()
                                   .collect(Collectors.toList());

        names.forEach(System.out::println);

        // Find the oldest person
        Optional<Person> oldestPerson = people.stream()
                                              .max(Comparator.comparing(Person::getAge));

        oldestPerson.ifPresent(person -> System.out.println("Oldest Person: " + person));

        // Group by city
        Map<String, List<Person>> peopleByCity = people.stream()
                                                       .collect(Collectors.groupingBy(Person::getCity));

        peopleByCity.forEach((city, peopleInCity) -> {
            System.out.println("People in " + city + ": " + peopleInCity);
        });

        // Calculate total and average age
        IntSummaryStatistics ageStatistics = people.stream()
                                                   .collect(Collectors.summarizingInt(Person::getAge));

        System.out.println("Total Age: " + ageStatistics.getSum());
        System.out.println("Average Age: " + ageStatistics.getAverage());
    }
}

Summary :
The Java Stream API is a powerful tool for working with collections and data. It allows for:

Filtering: Select elements based on a condition

Mapping: Transform elements

Collecting: Gather elements into collections or other data structures

Reducing: Combine elements into a single result.

FlatMapping: Flatten nested structures.

Sorting: Order elements.

Finding and Matching: Check elements against a condition.

Statistics: Perform statistical operations.

Understanding these features will help you write cleaner, more concise, and more readable code.

Happy Coding...

Java Records

Abhishek Singh — Sun, 09 Jun 2024 13:12:41 +0000

All About Java Records :

Overview :
Java Records, introduced in Java 14 as a preview feature and finalized in Java 16, provides a concise way to model immutable data. They simplify the boilerplate code needed for data-carrying classes by automatically generating methods like equals(), hashCode() and toString()

By the end of this post we will understand:

What records are in Java?
How to create and use records in Java?
The benefits of using records in Java?
And some limitations of records in Java?

What are Records?
A record in Java is a special kind of class that is designed to hold immutable data. It automatically provides implementations for methods like:

equals()
hashCode()
toString()
Getters for all fields

Why Use Records?
Records help reduce boilerplate code in data classes. Instead of writing constructors, getters, equals(), hashCode(), and toString() methods manually, we can define all of this with a single line of code

How to Define a Record?
Here's how we can define a simple record:

public record Point(int x, int y) {
}

This single line of code automatically provides:

A constructor
Getters (x() and y())
equals(), hashCode(), and toString() methods

Example: How to use Records?
Let's see how we can use the Point record:

public class Main {
    public static void main(String[] args) {
        Point point = new Point(3, 4);

        // Using the auto-generated toString() method
        System.out.println(point);  // Output: Point[x=3, y=4]

        // Accessing the fields using auto-generated methods
        System.out.println("X: " + point.x());  // Output: X: 3
        System.out.println("Y: " + point.y());  // Output: Y: 4
    }
}

Example: Custom Methods in Records :
You can also add custom methods to records:

public record Point(int x, int y) {
    public double distanceFromOrigin() {
        return Math.sqrt(x * x + y * y);
    }
}

public class Main {
    public static void main(String[] args) {
        Point point = new Point(3, 4);
        System.out.println("Distance from origin: " + point.distanceFromOrigin());  // Output: 5.0
    }
}

Custom Constructors :
We can also define custom constructors in records, but they must delegate to the canonical constructor:

public record Point(int x, int y) {
    public Point(int x) {
        this(x, 0);  // Delegating to the canonical constructor
    }
}

Limitations of Records :

1. Immutability: Records are immutable by design. You cannot change the values of their fields after creation.

2. No Inheritance: Records cannot extend other classes. They implicitly extend java.lang.Record

3. All-Args Constructor: We cannot create a no-argument constructor directly in records. We must always provide all the components.

When to Use Records :
Use records when:

We need a simple, immutable data carrier class
We want to reduce boilerplate code for equals(), hashCode(), and toString() methods
We don't need to extend another class or implement complex behavior

Practical Example :
Let's create a more complex example with a Person record:

public record Person(String name, int age) {
    public Person {
        // Custom constructor with validation
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
    }

    // Custom method
    public String greeting() {
        return "Hello, my name is " + name + " and I am " + age + " years old.";
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person.greeting());  // Output: Hello, my name is Alice and I am 30 years old.
        System.out.println(person);  // Output: Person[name=Alice, age=30]
    }
}

Key Points :

Definition:
public record Person(String name, int age) {}
Custom Constructor:
Validates that age is non-negative
Custom Method:
Adds a greeting() method

Conclusion :
Java Records provide a simple and powerful way to create immutable data classes with minimal boilerplate code. They are especially useful for modeling data transfer objects and other simple data carriers. By understanding and using records, you can write cleaner and more concise code.

Happy Coding...