Code Smell 266 - Collection Aliasing

by Maximiliano ContieriAugust 29th, 2024

Too Long; Didn't Read

To prevent unintended side effects and improve code reliability, use immutable collections in Java. Immutable collections eliminate aliasing issues, enhance predictability, and simplify debugging, making your code more robust and easier to manage.

featured image - Code Smell 266 - Collection Aliasing

Exposing your collections couples your solution

TL;DR: Use immutable collections to prevent unintended side effects.

Problems

Unpredictable behavior
Debugging challenges
Data corruption
Violation of the Principle of Least Astonishment
Premature optimization
Unexpected Mutations
Concurrency problems
Compromised thread safety
Increased coupling

Solutions

Use immutable collections
Create immutable classes
Copy the collection before modification
Avoid collection getters
Avoid automatic properties
Favor information hiding and encapsulation

Context

Aliasing happens when two or more variables refer to the same object.

This can lead to unexpected side effects, especially when one variable modifies the shared object.

You can't change immutable collections after creation helping you prevent accidental aliasing.

Premature optimizators will argue that copying collections is an expensive operation that you should avoid.

This is a special case of Object Aliasing

Sample Code

Wrong

public class MutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = numbers; // Aliasing
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3, 4]
  }
}

Right

public class ImmutableExample {
  public static void main(String[] args) {
    List<Integer> numbers = List.of(1, 2, 3);
    List<Integer> otherNumbers = List.copyOf(numbers); // Creating a copy
    otherNumbers.add(4);
    System.out.println(numbers); // Output: [1, 2, 3]
  }
}