Implement an immutable collection holder

 To implement an immutable collection holder, you need to ensure that the list of strings it holds cannot be modified after it is assigned. This can be done by creating an unmodifiable copy of the list in the constructor and returning an unmodifiable view of the list in the getter method. Using Collections.unmodifiableList is a common way to achieve this in Java.

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;


public class Main {

    public static void main(String[] args) {

        List<String> list = Arrays.asList("apple", "banana", "cherry");

        ImmutableCollectionHolder holder = Answer.createImmutableCollectionHolder(list);


        System.out.println("Immutable list: " + holder.getItems());


        // Try to modify the list through the getter

        try {

            holder.getItems().add("date");

        } catch (UnsupportedOperationException e) {

            System.out.println("Modification attempt failed: " + e);

        }


        // Try to modify the original list

        list.set(1, "blueberry");

        System.out.println("Immutable list after modifying original list: " + holder.getItems());

    }

}

class Answer {


    // Change these boolean values to control whether you see 

    // the expected result and/or hints.

    static boolean showExpectedResult = true;

    static boolean showHints = true;


    // Create a new ImmutableCollectionHolder with a list

    static ImmutableCollectionHolder createImmutableCollectionHolder(List<String> strings) {

        return new ImmutableCollectionHolder(strings);

    }


}


class ImmutableCollectionHolder {

    private final List<String> items;


    public ImmutableCollectionHolder(List<String> items) {

        // Create an unmodifiable copy of the list

        this.items = Collections.unmodifiableList(new ArrayList<>(items));

    }


    public List<String> getItems() {

        // Return the unmodifiable list

        return items;

    }

}

Explanation:

  1. Constructor:

    • The constructor takes a List<String> as an argument.
    • It creates a new ArrayList from the provided list to ensure that any subsequent modifications to the original list do not affect the internal list of the ImmutableCollectionHolder.
    • The Collections.unmodifiableList method is used to create an unmodifiable view of this new list, ensuring that the internal list cannot be modified.

  2. Getter:

    • The getItems method returns the unmodifiable list, ensuring that callers cannot modify the internal list.

Output:

Immutable list: [apple, banana, cherry]

Modification attempt failed: java.lang.UnsupportedOperationException

Immutable list after modifying original list: [apple, banana, cherry]


The ImmutableCollectionHolder ensures immutability by creating an unmodifiable copy of the input list and returning an unmodifiable view of this list. Any attempts to modify the list through the getter method will result in an UnsupportedOperationException, and changes to the original list will not affect the internal list of the ImmutableCollectionHolder.


Comments

Post a Comment

Popular posts from this blog

Transform values with a stream

The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
Read more

Collections Framework

 The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
Read more

Inspect a collection

Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
Read more