First Class Collection with Java

The concept of First Class Collections in software design treats collections of data as first-class citizens, allowing developers to encapsulate data management within dedicated collection classes or structures.

By adopting this methodology, developers can streamline their code, enhance readability, and facilitate more robust data handling.

First Class Collections not only promote cleaner architecture but also empower developers to leverage advanced functionalities such as filtering, sorting, and transforming data effectively.

In this article, we will explore the principles and benefits of  ✨First Class Collections ✨ in software design. You will discover practical examples, best practices, and tips for implementing this concept into your projects.

What is a first class collection

A First Class Collection in Java is a design principle where a class is created to encapsulate a collection and any associated behavior, without holding additional fields besides the collection itself. This helps in enhancing the management and operations related to that collection by encapsulating all functionalities in a single, cohesive unit.

From the Object Calisthenics document, the definition can be translated like this:

First class collections Application of this rule is simple: any class that contains a collection should contain no other member variables.
Each collection gets wrapped in its own class, so now behaviors related to the collection have a home. You may find that filters become a part of this new class. Also, your new class can handle activities like joining two groups together or applying a rule to each element of the group.

@ Rule 4 of Object Calisthenics

Why are we using a first class collection?

First class collections are used to improve encapsulation, making the code more modular and maintainable. By grouping the operations related to the collection within a single class, it simplifies interaction with the collection and enables the addition of behavior specific to the collection's domain. This design pattern helps prevent the scattering of collection logic across different parts of the codebase, enhancing readability and maintainability.

When to use a first class collection?

You should consider using a first class collection when you need to perform multiple operations on a collection or when the collection has specific rules or constraints that need to be enforced. This pattern is particularly beneficial when different parts of an application interact with the collection, and having a dedicated class helps centralize logic and operations, making the code easier to manage.

First class collection in practice

In this Java example, BookCollection it encapsulates a list of Book objects and provides methods to add, remove, and search books within the collection, ensuring all collection-related logic is centralized in one class.

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

class Book {
    private String title;
    private String author;
    private String isbn;

    // Constructor
    public Book(String title, String author, String isbn) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
    }

    // Getters
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    public String getIsbn() { return isbn; }

    @Override
    public String toString() {
        return title + " by " + author + " (ISBN: " + isbn + ")";
    }
}

// First class collection
class BookCollection {
    private List<Book> bookList;

    // Constructor
    public Books() {
        this.bookList = new ArrayList<>();
    }

    // Method to add a book
    public void addBook(Book book) {
        bookList.add(book);
    }

    // Method to remove a book
    public boolean removeBook(Book book) {
        return bookList.remove(book);
    }

    // Method to get all books
    public List<Book> getAllBooks() {
        return new ArrayList<>(bookList);
    }

    // Method to find a book by title
    public Book findBookByTitle(String title) {
        return bookList.stream()
                .filter(book -> book.getTitle().equalsIgnoreCase(title))
                .findFirst()
                .orElse(null);
    }

    // Method to find all books by an author
    public List<Book> findBooksByAuthor(String author) {
        return bookList.stream()
                .filter(book -> book.getAuthor().equalsIgnoreCase(author))
                .collect(Collectors.toList());
    }

    // Method to get the total number of books
    public int getTotalBooks() {
        return bookList.size();
    }

    // Method to check if a book exists in the collection
    public boolean containsBook(Book book) {
        return bookList.contains(book);
    }

    // Method to sort books by title
    public List<Book> sortBooksByTitle() {
        return bookList.stream()
                .sorted((b1, b2) -> b1.getTitle().compareToIgnoreCase(b2.getTitle()))
                .collect(Collectors.toList());
    }

    // Method to get book details as a string
    public String getBookDetails() {
        return bookList.stream()
                .map(Book::toString)
                .collect(Collectors.joining("\\n"));
    }

    // Additional utility methods can be added as needed
}

Pros and Cons

The advantages of using such a technique are pretty obvious.

• Improves encapsulation by centralizing all collection-related operations.
• Enhances code readability by organizing logic within a dedicated class.
• Simplifies future maintenance as updates to collection logic are isolated within the class.
• Allows inclusion of domain-specific collection behaviors.

But it can also have some cons

• Can increase complexity by introducing additional classes and lead to overengineering.
• Might add overhead for simple use cases where direct utilization of collections would suffice.