Best Java Libraries Every Developer Should Know

Java is one of the most popular programming languages in the world, known for its platform - independence, security, and robustness. Over the years, a vast ecosystem of libraries has been developed to simplify various programming tasks. These libraries provide pre - written code that developers can reuse, saving time and effort. In this blog, we will explore some of the best Java libraries that every developer should be familiar with.

Table of Contents

  1. Guava
    • Fundamental Concepts
    • Usage Methods
    • Common Practices
    • Best Practices
  2. Apache Commons Lang
    • Fundamental Concepts
    • Usage Methods
    • Common Practices
    • Best Practices
  3. Jackson
    • Fundamental Concepts
    • Usage Methods
    • Common Practices
    • Best Practices
  4. JUnit
    • Fundamental Concepts
    • Usage Methods
    • Common Practices
    • Best Practices
  5. SLF4J
    • Fundamental Concepts
    • Usage Methods
    • Common Practices
    • Best Practices

1. Guava

Fundamental Concepts

Guava is a set of core libraries for Java, developed by Google. It provides utilities for collections, caching, primitives support, concurrency, I/O, hashing, and more. Guava aims to make Java development more convenient and less error - prone.

Usage Methods

To use Guava in your project, you need to add the Guava dependency to your pom.xml if you are using Maven:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

Here is an example of using Guava’s Lists utility to create a new list:

import com.google.common.collect.Lists;
import java.util.List;

public class GuavaExample {
    public static void main(String[] args) {
        List<String> names = Lists.newArrayList("Alice", "Bob", "Charlie");
        System.out.println(names);
    }
}

Common Practices

  • Use Guava’s collections utilities to simplify collection creation and manipulation. For example, use ImmutableList to create an unmodifiable list.
import com.google.common.collect.ImmutableList;
import java.util.List;

public class ImmutableListExample {
    public static void main(String[] args) {
        List<String> immutableNames = ImmutableList.of("David", "Eve");
        // This will throw an UnsupportedOperationException
        // immutableNames.add("Frank"); 
        System.out.println(immutableNames);
    }
}

Best Practices

  • Use Guava’s Preconditions class to validate method arguments. This helps in making the code more robust and easier to debug.
import com.google.common.base.Preconditions;

public class PreconditionsExample {
    public static void printLength(String input) {
        Preconditions.checkNotNull(input, "Input cannot be null");
        System.out.println(input.length());
    }

    public static void main(String[] args) {
        printLength("Hello");
        // This will throw a NullPointerException with a custom message
        // printLength(null); 
    }
}

2. Apache Commons Lang

Fundamental Concepts

Apache Commons Lang is a library that provides a set of utility classes for the Java language. It includes methods for working with strings, numbers, dates, and arrays, among others.

Usage Methods

Add the Apache Commons Lang dependency to your pom.xml:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Here is an example of using StringUtils to check if a string is blank:

import org.apache.commons.lang3.StringUtils;

public class CommonsLangExample {
    public static void main(String[] args) {
        String str = "   ";
        boolean isBlank = StringUtils.isBlank(str);
        System.out.println(isBlank);
    }
}

Common Practices

  • Use RandomStringUtils to generate random strings.
import org.apache.commons.lang3.RandomStringUtils;

public class RandomStringUtilsExample {
    public static void main(String[] args) {
        String randomStr = RandomStringUtils.randomAlphabetic(10);
        System.out.println(randomStr);
    }
}

Best Practices

  • Use ObjectUtils to handle null objects in a more concise way.
import org.apache.commons.lang3.ObjectUtils;

public class ObjectUtilsExample {
    public static void main(String[] args) {
        String nullableStr = null;
        String defaultStr = ObjectUtils.defaultIfNull(nullableStr, "Default");
        System.out.println(defaultStr);
    }
}

3. Jackson

Fundamental Concepts

Jackson is a popular Java library for working with JSON data. It provides a simple and efficient way to serialize Java objects to JSON and deserialize JSON data back to Java objects.

Usage Methods

Add the Jackson dependency to your pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.4</version>
</dependency>

Here is an example of serializing a Java object to JSON:

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

class Person {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class JacksonExample {
    public static void main(String[] args) throws IOException {
        Person person = new Person("John", 30);
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(person);
        System.out.println(json);
    }
}

Common Practices

  • Use annotations like @JsonProperty to customize the JSON property names.
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

class Employee {
    @JsonProperty("full_name")
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getSalary() {
        return salary;
    }
}

public class JacksonAnnotationExample {
    public static void main(String[] args) throws IOException {
        Employee employee = new Employee("Jane", 5000);
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(employee);
        System.out.println(json);
    }
}

Best Practices

  • Configure the ObjectMapper to handle different JSON features, such as pretty - printing.
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;

class Book {
    private String title;
    private String author;

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

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }
}

public class JacksonPrettyPrintExample {
    public static void main(String[] args) throws IOException {
        Book book = new Book("Java Programming", "Author Name");
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.writerWithDefaultPrettyPrinter();
        String json = objectMapper.writeValueAsString(book);
        System.out.println(json);
    }
}

4. JUnit

Fundamental Concepts

JUnit is a unit testing framework for Java. It allows developers to write and run tests for their Java code. JUnit provides annotations and assertions to simplify the testing process.

Usage Methods

Add the JUnit dependency to your pom.xml:

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

Here is a simple JUnit test example:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);
    }
}

Common Practices

  • Use @BeforeEach and @AfterEach annotations to set up and tear down test data before and after each test method.
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class Database {
    public int getRecordCount() {
        return 10;
    }
}

public class DatabaseTest {
    private Database database;

    @BeforeEach
    public void setUp() {
        database = new Database();
    }

    @AfterEach
    public void tearDown() {
        database = null;
    }

    @Test
    public void testRecordCount() {
        int count = database.getRecordCount();
        assertEquals(10, count);
    }
}

Best Practices

  • Group related tests into test suites using @Suite and @SelectClasses annotations.
import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;

@Suite
@SelectClasses({CalculatorTest.class, DatabaseTest.class})
public class TestSuiteExample {
    // This class is used to group tests
}

5. SLF4J

Fundamental Concepts

SLF4J (Simple Logging Facade for Java) is a logging facade for Java. It provides a simple and consistent API for logging, allowing developers to choose different logging implementations at runtime.

Usage Methods

Add the SLF4J dependency to your pom.xml:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.36</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.11</version>
</dependency>

Here is an example of using SLF4J for logging:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SLF4JExample {
    private static final Logger logger = LoggerFactory.getLogger(SLF4JExample.class);

    public static void main(String[] args) {
        logger.info("This is an info message");
        logger.error("This is an error message");
    }
}

Common Practices

  • Use parameterized logging to avoid unnecessary string concatenation.
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ParameterizedLoggingExample {
    private static final Logger logger = LoggerFactory.getLogger(ParameterizedLoggingExample.class);

    public static void main(String[] args) {
        String name = "Tom";
        int age = 25;
        logger.info("Name: {}, Age: {}", name, age);
    }
}

Best Practices

  • Configure the logging level and output format in the logback.xml file. For example:
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

Conclusion

These are just a few of the many great Java libraries available. By using these libraries, developers can save a significant amount of time and effort, and write more robust, maintainable, and efficient code. Whether it’s for handling collections, working with JSON, writing tests, or logging, these libraries provide the tools needed to simplify the development process.

References