collections-java-api-2023

The List interface represents an ordered collection that allows duplicate elements. It functions similarly to a dynamic-length array, allowing you to add, remove, or replace elements based on their index.

Common implementations include:

• ArrayList: Uses a resizable array structure. It provides fast random access via indices but is slower when adding or removing elements from the middle due to element reallocation.
• LinkedList: Uses a doubly-linked list structure. It is highly efficient for adding or removing elements at the beginning or end of the list, but slower for index-based access as it requires traversing the list.
• Vector: A legacy implementation similar to ArrayList but synchronized (thread-safe). Because of the synchronization overhead, it is less efficient and less commonly used in modern applications unless concurrency is specifically required.

Java provides several implementations of the Map interface, each with different behaviors regarding ordering and null handling:

A collection is a data structure used to group multiple elements (which must be objects) into a single unit. Collections can be homogeneous (containing elements of a specific type) or heterogeneous.

The core of the framework is built around several key interfaces that allow you to manipulate data regardless of the underlying implementation details. The four main types of collections are:

• List: An ordered collection (sequence).
• Set: A collection that contains no duplicate elements.
• Queue: A collection designed for holding elements prior to processing (typically FIFO).
• Map: A collection that maps keys to values. Note that while Map is not a direct child of the Collection interface, it is functionally considered part of the collection framework.

All interfaces and classes are located in the java.util package.

The Collections utility class provides essential algorithms for manipulating List objects. Key operations include:

• sort: Orders the elements in the list.
• shuffle: Randomly reorders the elements.
• reverse: Reverses the order of elements.
• binarySearch: Performs a binary search on the list (requires the list to be sorted).

The Map interface is used to map data in the form of keys and values. In Java, a Map is an object that maps keys to values.

Key Characteristics:

• No Duplicate Keys: A Map cannot contain duplicate keys; each key can map to at most one value.
• Basic Operations:
  • put(K key, V value): Inserts or updates a mapping.
  • get(Object key): Retrieves the value associated with the key.
  • containsKey(Object key): Checks if the map contains a specific key.
  • containsValue(Object value): Checks if the map contains a specific value.
  • size(): Returns the number of key-value mappings.
  • isEmpty(): Checks if the map is empty.

The Set interface represents a collection that cannot contain duplicate elements, mirroring the mathematical concept of a set.

Key characteristics:

• No Duplicates: It ensures all elements are unique.
• No Random Access: Unlike a List, you cannot access elements by an index.
• Iteration: To traverse elements, use an Iterator or a foreach loop.

Common Implementations

Java provides several implementations of the Map interface, each with different performance characteristics and ordering guarantees:

The Collections utility class provides essential algorithms for manipulating List instances. You can use it to perform operations such as:

• Sorting (sort)
• Shuffling (shuffle)
• Reversing (reverse)
• Binary searching (binarySearch)

The Map interface is used to map data in the form of keys and values. In Java, a Map is an object that maps keys to values, with the following characteristics:

• No Duplicate Keys: A Map cannot contain duplicate keys; each key can map to at most one value.
• Basic Operations:
  • put(K key, V value): Inserts or updates a key-value pair.
  • get(Object key): Retrieves the value associated with the specified key.
  • containsKey(Object key): Checks if the map contains a specific key.
  • containsValue(Object value): Checks if the map contains a specific value.
  • size(): Returns the number of key-value mappings.
  • isEmpty(): Checks if the map is empty.

Sorting a List can be achieved using the Comparable interface for natural ordering or a Comparator for custom ordering.

Sorting Strategies:

• Natural Ordering (Comparable): Implement Comparable in your object class (e.g., Pessoa or Integer) to define a default sort order (like age or ascending numbers). Use Collections.sort() to apply it.
• Custom Ordering (Comparator): Use a Comparator to define alternative sorting logic, such as sorting Pessoa objects by altura (height) instead of age.
• Ascending/Descending: Use Collections utility methods to sort numbers in ascending or descending order.

To sort elements within a List, you can use two primary approaches depending on the requirement:

1. Using Comparable: Implement the Comparable interface on your object class to define a natural ordering. This allows you to sort the list using standard methods.
2. Using Comparator: Use a custom Comparator to define specific, non-natural ordering logic (e.g., sorting a Pessoa object by height instead of age).

You can also use the Collections class to perform ascending or descending sorts on lists of numbers.

Maps can be used to store complex objects as values to perform data analysis, such as inventory management or word frequency counting.

Inventory Management Pattern:

• Key: long (Product Code)
• Value: Produto object (containing nome, quantidade, and preco)
• Analysis Tasks:
  • Calculate total stock value (quantidade * preco).
  • Find the most expensive or cheapest product.
  • Find the product with the highest total value in stock.

Word Frequency Pattern:

• Key: String (Word)
• Value: Integer (Count)
• Analysis Tasks:
  • encontrarPalavraMaisFrequente(): Identify the word with the highest count.