{"id":1380,"date":"2023-09-14T12:51:12","date_gmt":"2023-09-14T12:51:12","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1380"},"modified":"2023-09-14T12:51:18","modified_gmt":"2023-09-14T12:51:18","slug":"java-arraylist-from-iteration-to-custom-objects","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/","title":{"rendered":"Java ArrayList: From Iteration to Custom Objects"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Brief about the Java Collections Framework<\/h3>\n\n\n\n

The Java Collections Framework (JCF) is a crucial and comprehensive set of classes and interfaces in Java’s standard library, designed explicitly for creating and manipulating collections of objects. These collections are essentially data structures that allow us to organize, store, and manage data efficiently.<\/p>\n\n\n\n

The JCF was introduced to offer a unified architecture for representing and manipulating collections. Before its introduction, Java developers often had to implement their data structures or rely on inconsistent APIs. The framework provides several benefits:<\/p>\n\n\n\n

    \n
  1. Performance<\/strong>: The standard collections in JCF are performance-optimized for most standard use-cases. This means developers can rely on them without worrying about the nitty-gritty details of data structure performance tuning.<\/li>\n\n\n\n
  2. Interoperability<\/strong>: All collection classes in JCF adhere to a set of standard interfaces (like List, Set, Queue, etc.). This promotes consistent usage patterns and makes it easier to switch between different collection types or to make them work in tandem.<\/li>\n\n\n\n
  3. Extensibility<\/strong>: While JCF provides a robust set of pre-implemented data structures, it’s also designed to be extensible. Developers can easily extend existing classes or interfaces to create specialized collections tailored for specific needs.<\/li>\n\n\n\n
  4. Concurrent Implementations<\/strong>: The framework also offers thread-safe or concurrent collection variants that help in building efficient multi-threaded applications.<\/li>\n<\/ol>\n\n\n\n

    Why use ArrayList?<\/h3>\n\n\n\n

    ArrayList is one of the most popular implementations of the List interface provided by the JCF. Here’s why developers gravitate towards using it:<\/p>\n\n\n\n

      \n
    1. Dynamic Resizing<\/strong>: Unlike standard arrays in Java, which have a fixed size once declared, ArrayLists can dynamically resize themselves. This ensures that you don\u2019t waste memory on pre-allocated, unused elements or run out of space when storing elements beyond an array’s initial capacity.<\/li>\n\n\n\n
    2. Convenience and Ease of Use<\/strong>: ArrayList provides utility methods for common operations like adding, removing, or fetching elements which are not directly available with arrays.<\/li>\n\n\n\n
    3. Indexed Access<\/strong>: ArrayLists, being a part of the List family, allow for efficient indexed access and modification of elements. This makes them suitable for use-cases where frequent read, add, or update operations based on an index are required.<\/li>\n\n\n\n
    4. Null and Duplicates<\/strong>: ArrayList can store null elements and allows duplicates. This provides flexibility in scenarios where such requirements are essential.<\/li>\n\n\n\n
    5. Integration with Other Java APIs<\/strong>: ArrayList seamlessly integrates with various other Java APIs and libraries, making it easier to transform, process, or transmit data.<\/li>\n\n\n\n
    6. Generics Support<\/strong>: Introduced in Java 5, generics allow for type-safe operations. With ArrayList, you can ensure that only a specific type of objects gets stored, thus minimizing runtime type errors.<\/li>\n<\/ol>\n\n\n\n

      ArrayList Basics<\/h2>\n\n\n\n

      Declaration and Initialization<\/h3>\n\n\n\n

      ArrayList is a part of the Java Collections Framework and is a resizable array implementation of the List interface. To declare and initialize an ArrayList, the following syntax is used:<\/p>\n\n\n

      ArrayList<E> list = new<\/span> ArrayList<>();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      Here, E<\/code> denotes the type of elements this ArrayList will store. It could be any object type like Integer<\/code>, String<\/code>, CustomObject<\/code>, etc. If you’re using Java 7 and above, you can use the diamond operator (<><\/code>) during initialization to infer the type from the declaration.<\/p>\n\n\n\n
      Example:<\/p>\n\n\n
      ArrayList<String> names = new<\/span> ArrayList<>();\r\nArrayList<Integer> numbers = new<\/span> ArrayList<>();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
      Size and Capacity: Understanding the difference<\/h3>\n\n\n\n
      The terms “size” and “capacity” are frequently used when discussing ArrayList, but they represent different concepts:<\/p>\n\n\n\n
        \n
      • Size<\/strong>: It refers to the number of elements that the ArrayList currently holds. You can get the size of an ArrayList using the size()<\/code> method.<\/li>\n<\/ul>\n\n\n
        names.add(\"Alice\"<\/span>);\r\nnames.add(\"Bob\"<\/span>);\r\nSystem.out.println(names.size());  \/\/ Outputs: 2<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
          \n
        • Capacity<\/strong>: It refers to the total number of elements an ArrayList can hold without resizing its internal array. Initially, when you create an empty ArrayList without specifying any capacity, it has a default capacity (usually 10, but this might vary depending on the Java version). When elements are added beyond this capacity, the ArrayList dynamically resizes by increasing its capacity (typically, it doubles the current capacity). You cannot directly get the capacity of an ArrayList in Java as there\u2019s no public method for this. However, understanding this behavior is crucial for performance considerations.<\/li>\n<\/ul>\n\n\n\n
          ArrayList vs. Array: Pros and Cons<\/h3>\n\n\n\n
          Both arrays and ArrayLists are fundamental data structures in Java, but they have different use cases, advantages, and disadvantages.<\/p>\n\n\n\n
          Array<\/strong>:<\/p>\n\n\n\n
            \n
          • Pros<\/strong>:\n
              \n
            • Fixed size: This can be a benefit when you know exactly how many elements you’ll be dealing with.<\/li>\n\n\n\n
            • Performance: Arrays might have a slight performance edge over ArrayLists since there’s no overhead of additional methods or dynamic resizing.<\/li>\n\n\n\n
            • Simple Syntax: Arrays offer straightforward syntax for declaration and initialization.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
            • Cons<\/strong>:\n
                \n
              • Fixed size: It\u2019s a double-edged sword. Once an array’s size is set, it cannot be changed without creating a new array.<\/li>\n\n\n\n
              • No Built-in Methods: Arrays don\u2019t come with built-in methods for operations like insertion, deletion, or contains check. You have to manually manage these or use utility classes like Arrays<\/code>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                ArrayList<\/strong>:<\/p>\n\n\n\n
                  \n
                • Pros<\/strong>:\n
                    \n
                  • Dynamic resizing: ArrayList can grow or shrink as required.<\/li>\n\n\n\n
                  • Built-in Methods: ArrayList provides numerous methods to easily manipulate data, like add()<\/code>, remove()<\/code>, contains()<\/code>, etc.<\/li>\n\n\n\n
                  • Generics Support: ArrayList supports generics, ensuring type safety.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                  • Cons<\/strong>:\n
                      \n
                    • Overhead: Due to additional methods and dynamic resizing, ArrayLists might introduce some overhead.<\/li>\n\n\n\n
                    • Initial Capacity: ArrayLists start with a default capacity, which might lead to memory wastage if not used. However, this can be managed using constructors that define initial capacity.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                      The choice between ArrayList and array should be based on specific requirements. For applications requiring dynamic data structures with frequent resizing and utility methods, ArrayList is the preferred choice. However, for performance-critical scenarios where the number of elements is known and fixed, arrays can be more suitable.<\/p>\n\n\n\n
                      Adding Elements to ArrayList<\/h2>\n\n\n\n
                      ArrayLists in Java are dynamic, which means you can add elements to them after they have been declared. Let’s dive into the various methods available for adding elements to an ArrayList.<\/p>\n\n\n\n
                      add(E e)<\/code> Method<\/h3>\n\n\n\n
                      This method is used to append an element to the end of an ArrayList.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      boolean<\/span> add<\/span>(E e)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\nfruits.add(\"Cherry\"<\/span>);\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Banana, Cherry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      add(int index, E element)<\/code> Method<\/h3>\n\n\n\n
                      This method inserts a specific element at a specified position in the ArrayList, shifting the current element and any subsequent elements to the right.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      void<\/span> add<\/span>(int<\/span> index, E element)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String<\/span>> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Cherry\"<\/span>);\r\nfruits.add(1<\/span>, \"Banana\"<\/span>); \/\/ Inserting \"Banana\" at index 1<\/span>\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Banana, Cherry]<\/span><\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Note: It’s essential to ensure that the index is within the range of the ArrayList size (including 0). If you provide an index out of this range, an IndexOutOfBoundsException<\/code> will be thrown.<\/p>\n\n\n\n
                      Bulk Addition: addAll(Collection<? extends E> c)<\/code> Method<\/h3>\n\n\n\n
                      This method is employed to append all elements from a collection to the end of an ArrayList. This is especially useful when you want to merge two lists or add multiple elements at once.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      boolean<\/span> addAll<\/span>(Collection<? extends E> c)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\n\r\nArrayList<String> moreFruits = new<\/span> ArrayList<>();\r\nmoreFruits.add(\"Cherry\"<\/span>);\r\nmoreFruits.add(\"Date\"<\/span>);\r\nmoreFruits.add(\"Elderberry\"<\/span>);\r\n\r\nfruits.addAll(moreFruits); \/\/ Adding all elements from moreFruits to fruits<\/span>\r\n\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Banana, Cherry, Date, Elderberry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Additionally, there’s an overloaded version of the addAll<\/code> method which allows you to add a collection at a specific index:<\/p>\n\n\n
                      boolean<\/span> addAll<\/span>(int<\/span> index, Collection<? extends E> c)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      For instance:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\n\r\nArrayList<String> berries = new<\/span> ArrayList<>();\r\nberries.add(\"Strawberry\"<\/span>);\r\nberries.add(\"Blueberry\"<\/span>);\r\n\r\nfruits.addAll(1<\/span>, berries); \/\/ Inserting all berries at index 1<\/span>\r\n\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Strawberry, Blueberry, Banana]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      With these methods at your disposal, adding elements to an ArrayList becomes an effortless task, whether it’s a single addition, a specific indexed addition, or a bulk addition.<\/p>\n\n\n\n
                      Accessing Elements in ArrayList<\/h2>\n\n\n\n
                      ArrayLists in Java provide multiple ways to access their elements. Whether you want to fetch a specific item or traverse the entire list, various methods make these tasks straightforward.<\/p>\n\n\n\n
                      Using the get(int index)<\/code> Method<\/h3>\n\n\n\n
                      The get()<\/code> method allows you to retrieve an element from a specific position in the ArrayList.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      E get<\/span>(int<\/span> index)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\nfruits.add(\"Cherry\"<\/span>);\r\n\r\nString fruit = fruits.get(1<\/span>); \/\/ Accessing element at index 1<\/span>\r\nSystem.out.println(fruit); \/\/ Outputs: Banana<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Iterating through an ArrayList<\/h3>\n\n\n\n
                      Using Iterator<\/h4>\n\n\n\n
                      The Iterator<\/code> interface provides a way to access elements sequentially without exposing the underlying structure.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nIterator<String> iterator = fruits.iterator();\r\n\r\nwhile<\/span>(iterator.hasNext()) {\r\n    String fruit = iterator.next();\r\n    System.out.println(fruit);\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Using ListIterator (forward and backward iteration)<\/h4>\n\n\n\n
                      ListIterator<\/code> extends Iterator<\/code> and allows both forward and backward iteration through the list. It offers methods like hasPrevious()<\/code>, previous()<\/code>, and more.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nListIterator<String> listIterator = fruits.listIterator();\r\n\r\n\/\/ Forward Iteration<\/span>\r\nwhile<\/span>(listIterator.hasNext()) {\r\n    String fruit = listIterator.next();\r\n    System.out.println(fruit);\r\n}\r\n\r\n\/\/ Backward Iteration<\/span>\r\nwhile<\/span>(listIterator.hasPrevious()) {\r\n    String fruit = listIterator.previous();\r\n    System.out.println(fruit);\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Using for-each loop<\/h4>\n\n\n\n
                      The for-each loop, introduced in Java 5, makes iterating through collections more concise.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nfor<\/span>(String fruit : fruits) {\r\n    System.out.println(fruit);\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Using Java 8 Streams<\/h4>\n\n\n\n
                      With Java 8, the Stream API was introduced, allowing a more functional approach to processing sequences of elements.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nfruits.stream().forEach(fruit -> System.out.println(fruit));<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Or even more concise with method references:<\/p>\n\n\n
                      fruits.stream().forEach(System.out::println);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Modifying Elements in ArrayList<\/h2>\n\n\n\n
                      One of the strengths of the ArrayList in Java is its flexibility in modifying the elements. Not only can you add or remove items, but you can also change the value of existing elements with ease.<\/p>\n\n\n\n
                      Setting values: set(int index, E element)<\/code> Method<\/h3>\n\n\n\n
                      This method is used to replace an element at a specific position in the ArrayList with a given element.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      E set<\/span>(int<\/span> index, E element)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The method returns the element previously at the specified position.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> colors = new<\/span> ArrayList<>();\r\ncolors.add(\"Red\"<\/span>);\r\ncolors.add(\"Blue\"<\/span>);\r\ncolors.add(\"Yellow\"<\/span>);\r\n\r\nSystem.out.println(colors); \/\/ Outputs: [Red, Blue, Yellow]<\/span>\r\n\r\n\/\/ Replacing the value at index 1 (Blue) with Green<\/span>\r\ncolors.set(1<\/span>, \"Green\"<\/span>);\r\n\r\nSystem.out.println(colors); \/\/ Outputs: [Red, Green, Yellow]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Batch Operations for Modification<\/h3>\n\n\n\n
                      In many scenarios, you may want to perform batch operations to modify multiple elements in an ArrayList. Here are some approaches:<\/p>\n\n\n\n
                      Using replaceAll(UnaryOperator<E> operator)<\/code> Method<\/h4>\n\n\n\n
                      This method, introduced in Java 8, replaces each element of the list with the result of applying the given operator.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<Integer> numbers = new<\/span> ArrayList<>(Arrays.asList(1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>));\r\n\r\n\/\/ Doubling each number in the list<\/span>\r\nnumbers.replaceAll(n -> n * 2<\/span>);\r\n\r\nSystem.out.println(numbers); \/\/ Outputs: [2, 4, 6, 8, 10]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Using Java 8 Streams for Modification<\/h4>\n\n\n\n
                      While streams are primarily designed for queries and not modifications, you can still use them in conjunction with collectors to produce a modified list.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> words = new<\/span> ArrayList<>(Arrays.asList(\"apple\"<\/span>, \"banana\"<\/span>, \"cherry\"<\/span>));\r\n\r\n\/\/ Capitalizing each word in the list using streams<\/span>\r\nList<String> capitalizedWords = words.stream()\r\n                                     .map(String::toUpperCase)\r\n                                     .collect(Collectors.toList());\r\n\r\nSystem.out.println(capitalizedWords); \/\/ Outputs: [APPLE, BANANA, CHERRY]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Note that the original list (words<\/code>) remains unchanged, and we get a new list (capitalizedWords<\/code>) with the modifications.<\/p>\n\n\n\n
                      Using Iterators for In-Place Modification<\/h4>\n\n\n\n
                      Iterators, particularly ListIterator<\/code>, can also be used for in-place modifications of elements.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> words = new<\/span> ArrayList<>(Arrays.asList(\"apple\"<\/span>, \"banana\"<\/span>, \"cherry\"<\/span>));\r\nListIterator<String> iterator = words.listIterator();\r\n\r\nwhile<\/span>(iterator.hasNext()) {\r\n    String currentWord = iterator.next();\r\n    iterator.set(currentWord.toUpperCase());\r\n}\r\n\r\nSystem.out.println(words); \/\/ Outputs: [APPLE, BANANA, CHERRY]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      In this approach, the original list is modified directly.<\/p>\n\n\n\n
                      Removing Elements from ArrayList<\/h2>\n\n\n\n
                      ArrayLists in Java offer several convenient methods to remove elements. Whether you’re targeting a single element, multiple elements, or even the entire list, these methods provide an efficient way to achieve your goal.<\/p>\n\n\n\n
                      remove(int index)<\/code> Method<\/h3>\n\n\n\n
                      This method is used to remove an element at a specified index from the ArrayList. It shifts any subsequent elements to the left, subtracting one from their indices.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      E remove<\/span>(int<\/span> index)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The method returns the element that was removed.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\nfruits.add(\"Cherry\"<\/span>);\r\n\r\nString removedFruit = fruits.remove(1<\/span>); \/\/ Removing element at index 1<\/span>\r\nSystem.out.println(removedFruit);  \/\/ Outputs: Banana<\/span>\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Cherry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      remove(Object o)<\/code> Method<\/h3>\n\n\n\n
                      This method removes the first occurrence of the specified element from the ArrayList, if it is present.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      boolean<\/span> remove<\/span>(Object o)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      The method returns true<\/code> if the element was found and removed, otherwise false<\/code>.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>();\r\nfruits.add(\"Apple\"<\/span>);\r\nfruits.add(\"Banana\"<\/span>);\r\nfruits.add(\"Cherry\"<\/span>);\r\n\r\nboolean<\/span> isRemoved = fruits.remove(\"Banana\"<\/span>);\r\nSystem.out.println(isRemoved);  \/\/ Outputs: true<\/span>\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Cherry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Bulk Removal<\/h3>\n\n\n\n
                      removeAll(Collection<?> c)<\/code> Method<\/h4>\n\n\n\n
                      This method removes from the ArrayList all of its elements that are contained in the specified collection.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      boolean<\/span> removeAll<\/span>(Collection<?> c)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>, \"Date\"<\/span>, \"Elderberry\"<\/span>));\r\nArrayList<String> fruitsToRemove = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Date\"<\/span>));\r\n\r\nfruits.removeAll(fruitsToRemove);\r\nSystem.out.println(fruits); \/\/ Outputs: [Banana, Cherry, Elderberry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      retainAll(Collection<?> c)<\/code> Method<\/h4>\n\n\n\n
                      This method retains only the elements in the ArrayList that are contained in the specified collection, removing all others.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      boolean<\/span> retainAll<\/span>(Collection<?> c)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>, \"Date\"<\/span>, \"Elderberry\"<\/span>));\r\nArrayList<String> fruitsToRetain = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Cherry\"<\/span>));\r\n\r\nfruits.retainAll(fruitsToRetain);\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Cherry]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Clearing All Elements: clear()<\/code> Method<\/h3>\n\n\n\n
                      This method removes all the elements from the ArrayList, effectively clearing it.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      void<\/span> clear<\/span>()<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nfruits.clear();\r\nSystem.out.println(fruits); \/\/ Outputs: []<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      ArrayList and Multithreading<\/h2>\n\n\n\n
                      ArrayList is one of the most commonly used implementations of the List interface in Java. However, when it comes to concurrent programming and multithreading, there are specific challenges and considerations you should be aware of.<\/p>\n\n\n\n
                      Understanding the Non-Thread Safety of ArrayList<\/h3>\n\n\n\n
                      An ArrayList<\/code> is not thread-safe, meaning that if multiple threads access it concurrently and at least one of the threads modifies it structurally, it must be synchronized externally. Structural modifications include adding or removing elements.<\/p>\n\n\n\n
                      When an ArrayList<\/code> undergoes concurrent modification without appropriate synchronization, the outcomes can be unpredictable. There’s no guarantee that one thread’s changes are visible to another thread, which can lead to data inconsistency.<\/p>\n\n\n\n
                      Concurrent Modification Exception: What and Why?<\/h3>\n\n\n\n
                      What?<\/strong> The ConcurrentModificationException<\/code> is a runtime exception that can be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.<\/p>\n\n\n\n
                      Why?<\/strong> Imagine a scenario where one thread is iterating over an ArrayList, and another thread modifies it by adding or removing elements. This could lead to unexpected results or errors during the iteration process. For instance, if an element is removed from a list while it’s being iterated over, the iteration could skip some elements or throw an error due to unexpected resizing.<\/p>\n\n\n\n
                      To mitigate such issues, the iterator of ArrayList (and many other collections in Java’s standard library) checks if the list has been modified after the iterator was created. If it detects such modifications, it throws a ConcurrentModificationException<\/code>.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> list = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>));\r\nfor<\/span> (String item : list) {\r\n    if<\/span> (\"B\"<\/span>.equals(item)) {\r\n        list.remove(item);  \/\/ This will throw ConcurrentModificationException<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Synchronized ArrayList using Collections.synchronizedList()<\/code><\/h3>\n\n\n\n
                      To make an ArrayList thread-safe, Java provides a utility method: Collections.synchronizedList()<\/code>. This method returns a synchronized (thread-safe) list backed by the specified list.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      List<E> synchronizedList = Collections.synchronizedList(new<\/span> ArrayList<E>());<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      List<String> syncList = Collections.synchronizedList(new<\/span> ArrayList<>());\r\nsyncList.add(\"A\"<\/span>);\r\nsyncList.add(\"B\"<\/span>);\r\nsyncList.add(\"C\"<\/span>);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      However, it’s essential to note that while individual operations on the synchronized list are thread-safe, compound operations (like iterations) are not necessarily so. For such operations, you’d need to synchronize on the list itself:<\/p>\n\n\n
                      synchronized<\/span>(syncList) {\r\n    for<\/span> (String item : syncList) {\r\n        \/\/ process item<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      While ArrayLists are incredibly efficient for single-threaded applications, they require additional considerations and adaptations when used in multithreaded environments. By understanding these challenges and using tools like Collections.synchronizedList()<\/code>, you can ensure the thread safety of your ArrayList operations.<\/p>\n\n\n\n
                      Searching and Sorting in ArrayList<\/h2>\n\n\n\n
                      ArrayLists in Java offer a range of methods to perform search and sort operations. Being a part of the broader Collections framework, ArrayList benefits from several utility methods provided by the Collections<\/code> class.<\/p>\n\n\n\n
                      Searching in ArrayList<\/h3>\n\n\n\n
                      indexOf(Object o)<\/code> Method<\/h4>\n\n\n\n
                      The indexOf()<\/code> method returns the index of the first occurrence of the specified element in the ArrayList, or -1 if the list doesn’t contain the element.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      int<\/span> indexOf<\/span>(Object o)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> colors = new<\/span> ArrayList<>(Arrays.asList(\"Red\"<\/span>, \"Green\"<\/span>, \"Blue\"<\/span>, \"Green\"<\/span>));\r\nint<\/span> index = colors.indexOf(\"Green\"<\/span>);\r\nSystem.out.println(index); \/\/ Outputs: 1<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      lastIndexOf(Object o)<\/code> Method<\/h4>\n\n\n\n
                      The lastIndexOf()<\/code> method returns the index of the last occurrence of the specified element, or -1 if the list doesn’t contain the element.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      int<\/span> lastIndexOf<\/span>(Object o)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> colors = new<\/span> ArrayList<>(Arrays.asList(\"Red\"<\/span>, \"Green\"<\/span>, \"Blue\"<\/span>, \"Green\"<\/span>));\r\nint<\/span> lastIndex = colors.lastIndexOf(\"Green\"<\/span>);\r\nSystem.out.println(lastIndex); \/\/ Outputs: 3<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Sorting in ArrayList<\/h3>\n\n\n\n
                      Using Collections.sort()<\/code> Method with Custom Comparators<\/strong><\/p>\n\n\n\n
                      Java provides the Collections.sort()<\/code> method to sort lists, including ArrayLists. By default, it sorts in natural order, but you can provide a custom Comparator<\/code> to dictate the sort order.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> fruits = new<\/span> ArrayList<>(Arrays.asList(\"Apple\"<\/span>, \"Banana\"<\/span>, \"Cherry\"<\/span>));\r\nCollections.sort(fruits);\r\nSystem.out.println(fruits); \/\/ Outputs: [Apple, Banana, Cherry]<\/span>\r\n\r\n\/\/ Sorting in descending order using a custom comparator<\/span>\r\nCollections.sort(fruits, Comparator.reverseOrder());\r\nSystem.out.println(fruits); \/\/ Outputs: [Cherry, Banana, Apple]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Binary Search in ArrayList<\/h3>\n\n\n\n
                      Using Collections.binarySearch()<\/code> Method<\/strong><\/p>\n\n\n\n
                      The Collections.binarySearch()<\/code> method allows you to efficiently search for an element in a sorted<\/strong> list. If the list is not sorted, the results are undefined.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      int<\/span> binarySearch<\/span>(List<? extends Comparable<? super<\/span> T>> list, T key)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      For custom objects or specific sorting orders, you can also pass a Comparator<\/code>.<\/p>\n\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<Integer> numbers = new<\/span> ArrayList<>(Arrays.asList(1<\/span>, 3<\/span>, 5<\/span>, 7<\/span>, 9<\/span>));\r\nint<\/span> index = Collections.binarySearch(numbers, 5<\/span>);\r\nSystem.out.println(index); \/\/ Outputs: 2<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Cloning and Converting ArrayList<\/h2>\n\n\n\n
                      The ability to clone and convert ArrayLists to other data types in Java, like arrays, and vice versa, is essential for efficient data manipulation and transformation. Below, we explore these processes in detail.<\/p>\n\n\n\n
                      Cloning an ArrayList<\/h3>\n\n\n\n
                      clone()<\/code> Method: Creating a Shallow Copy<\/strong><\/p>\n\n\n\n
                      The clone()<\/code> method of the ArrayList<\/code> class is used to create a copy of the ArrayList. However, it’s crucial to note that this is a shallow copy. While the ArrayList itself is a new instance, the elements inside are references to the same objects as the original list.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      Object<\/span> clone()<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> originalList = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>));\r\nArrayList<String> clonedList = (ArrayList<String>) originalList.clone();\r\n\r\nSystem.out.println(clonedList); \/\/ Outputs: [A, B, C]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Converting ArrayList to Array<\/h3>\n\n\n\n
                      toArray(T[] a)<\/code> Method<\/strong><\/p>\n\n\n\n
                      This method returns an array containing all the elements in the list in the proper order. The runtime type of the returned array is that of the provided array.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      <T> T[] toArray(T[] a)<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      ArrayList<String> list = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>));\r\nString[] array = list.toArray(new<\/span> String[0<\/span>]);\r\n\r\nSystem.out.println(Arrays.toString(array)); \/\/ Outputs: [A, B, C]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Converting Array to ArrayList<\/h3>\n\n\n\n
                      Arrays.asList(T... a)<\/code> Method<\/strong><\/p>\n\n\n\n
                      This utility method provided by the Arrays<\/code> class returns a fixed-size list backed by the specified array. This implies that any changes to the returned list are reflected in the original array and vice-versa.<\/p>\n\n\n\n
                      Syntax<\/strong>:<\/p>\n\n\n
                      static<\/span> <T> List<T> asList<\/span>(T... a)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      Example<\/strong>:<\/p>\n\n\n
                      String[] array = {\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>};\r\nList<String> list = Arrays.asList(array);\r\n\r\nlist.set(0<\/span>, \"X\"<\/span>); \/\/ Modifying the list also changes the original array<\/span>\r\nSystem.out.println(list); \/\/ Outputs: [X, B, C]<\/span>\r\nSystem.out.println(Arrays.toString(array)); \/\/ Outputs: [X, B, C]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                      It’s important to note that the list returned from Arrays.asList()<\/code> has a fixed size. This means methods like add()<\/code> or remove()<\/code> will throw UnsupportedOperationException<\/code>.<\/p>\n\n\n\n
                      ArrayList with Custom Objects<\/h2>\n\n\n\n
                      When working with ArrayLists that store custom objects, it’s crucial to understand the significance of overriding methods like equals()<\/code>, hashCode()<\/code>, and potentially compareTo()<\/code>. These methods play a pivotal role in operations such as searching, removing, sorting, and storing objects in hashed data structures.<\/p>\n\n\n\n
                      The Importance of Overriding<\/h3>\n\n\n\n
                        \n
                      • equals()<\/code> Method<\/strong>: By default, the equals()<\/code> method in the Object<\/code> class checks for reference equality. If you want to compare two objects based on their content, you need to override the equals()<\/code> method.<\/li>\n\n\n\n
                      • hashCode()<\/code> Method<\/strong>: If you override the equals()<\/code> method, you must also override the hashCode()<\/code> method. This is to ensure that equal objects produce the same hash code, which is a fundamental contract for storing objects in hashed data structures like HashSet<\/code> or HashMap<\/code>.<\/li>\n\n\n\n
                      • compareTo()<\/code> Method<\/strong>: If you intend to sort custom objects or store them in sorted collections like TreeSet<\/code>, your custom class should implement the Comparable<\/code> interface and override the compareTo()<\/code> method. This method defines the natural order of objects.<\/li>\n<\/ul>\n\n\n\n
                        Examples<\/h3>\n\n\n\n
                        Creating a Custom Class Student<\/code><\/strong>:<\/p>\n\n\n
                        class<\/span> Student<\/span> implements<\/span> Comparable<\/span><Student<\/span>> <\/span>{\r\n    private<\/span> int<\/span> id;\r\n    private<\/span> String name;\r\n\r\n    \/\/ Constructor, getters, setters...<\/span>\r\n\r\n    @Override<\/span>\r\n    public<\/span> boolean<\/span> equals<\/span>(Object obj)<\/span> <\/span>{\r\n        if<\/span> (this<\/span> == obj) return<\/span> true<\/span>;\r\n        if<\/span> (obj == null<\/span> || getClass() != obj.getClass()) return<\/span> false<\/span>;\r\n        Student student = (Student) obj;\r\n        return<\/span> id == student.id && name.equals(student.name);\r\n    }\r\n\r\n    @Override<\/span>\r\n    public<\/span> int<\/span> hashCode<\/span>()<\/span> <\/span>{\r\n        return<\/span> Objects.hash(id, name);\r\n    }\r\n\r\n    @Override<\/span>\r\n    public<\/span> int<\/span> compareTo<\/span>(Student other)<\/span> <\/span>{\r\n        return<\/span> Integer.compare(this<\/span>.id, other.id);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                        Creating an ArrayList of Custom Objects and Performing Operations<\/strong>:<\/p>\n\n\n
                        ArrayList<Student> students = new<\/span> ArrayList<>();\r\nstudents.add(new<\/span> Student(1<\/span>, \"Alice\"<\/span>));\r\nstudents.add(new<\/span> Student(2<\/span>, \"Bob\"<\/span>));\r\nstudents.add(new<\/span> Student(3<\/span>, \"Charlie\"<\/span>));\r\n\r\n\/\/ Searching for an object<\/span>\r\nStudent bob = new<\/span> Student(2<\/span>, \"Bob\"<\/span>);\r\nint<\/span> index = students.indexOf(bob);\r\nSystem.out.println(index); \/\/ Outputs: 1 because Alice's index is 0<\/span>\r\n\r\n\/\/ Removing an object<\/span>\r\nstudents.remove(bob);\r\n\r\n\/\/ Sorting the list (based on the compareTo method in Student class)<\/span>\r\nCollections.sort(students);<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                        Notice how the custom implementations of equals()<\/code> and hashCode()<\/code> enable the indexOf()<\/code> and remove()<\/code> methods to work seamlessly with our custom objects. The compareTo()<\/code> method provides a natural order when sorting the ArrayList.<\/p>\n\n\n\n
                        ArrayList and Memory Management<\/h2>\n\n\n\n
                        Java’s ArrayList offers a dynamic array implementation of the List interface. While arrays in Java have a fixed size once created, ArrayLists can grow and shrink as needed. This flexibility comes with its own intricacies concerning memory management.<\/p>\n\n\n\n
                        Understanding How ArrayList Grows (Dynamically Resizing)<\/h3>\n\n\n\n
                          \n
                        • Initial Capacity<\/strong>: When you create an ArrayList without specifying an initial capacity, it starts with a default initial capacity (typically 10, though this may vary between Java implementations).<\/li>\n\n\n\n
                        • Resizing<\/strong>: As elements get added to the ArrayList and it reaches its capacity, it needs to grow. The ArrayList achieves this by creating a new array with larger capacity and copying the elements from the old array to the new one. Typically, the new capacity is 1.5 times the old capacity. This resizing operation can be expensive in terms of time complexity, especially if it occurs frequently.<\/li>\n<\/ul>\n\n\n\n
                          Trimming to Size: trimToSize()<\/code> Method<\/h3>\n\n\n\n
                          Over the course of its lifecycle, the actual number of elements in an ArrayList might become significantly less than its current capacity, especially after several add and remove operations. The excess reserved memory can be a wastage, especially in memory-constrained environments.<\/p>\n\n\n\n
                          The trimToSize()<\/code> method trims the capacity of the ArrayList instance to be the list’s current size. This can help minimize the storage of an ArrayList.<\/p>\n\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<Integer> numbers = new<\/span> ArrayList<>(100<\/span>); \/\/ Initial capacity set to 100<\/span>\r\nnumbers.add(1<\/span>);\r\nnumbers.add(2<\/span>);\r\nnumbers.add(3<\/span>);\r\n\r\n\/\/ Trim the capacity from 100 to 3 (the actual number of elements)<\/span>\r\nnumbers.trimToSize();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Ensuring Capacity: ensureCapacity(int minCapacity)<\/code> Method<\/h3>\n\n\n\n
                          Sometimes, you might know in advance that your ArrayList will grow to hold a large number of elements. To avoid frequent resizing operations, which can be expensive, you can use the ensureCapacity()<\/code> method. This method ensures that the ArrayList can hold at least the number of elements specified by the minimum capacity argument without needing to undergo resizing.<\/p>\n\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<Integer> numbers = new<\/span> ArrayList<>();\r\nnumbers.ensureCapacity(100<\/span>); \/\/ Pre-allocate space for 100 elements<\/span>\r\n\r\nfor<\/span> (int<\/span> i = 0<\/span>; i < 100<\/span>; i++) {\r\n    numbers.add(i);\r\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          In the above example, despite adding 100 elements, the ArrayList won’t need to resize since we’ve ensured the required capacity in advance.<\/p>\n\n\n\n
                          Useful ArrayList Methods<\/h2>\n\n\n\n
                          ArrayList<\/code> in Java is packed with numerous utility methods that enable developers to manipulate, query, and interact with the data efficiently. Let’s explore some of these handy methods:<\/p>\n\n\n\n
                          Basic Inspection Methods<\/h3>\n\n\n\n
                          isEmpty()<\/code> Method:<\/h4>\n\n\n\n
                          This method checks if the ArrayList is empty or not.<\/p>\n\n\n\n
                          Syntax<\/strong>:<\/p>\n\n\n
                          boolean<\/span> isEmpty<\/span>()<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<String> list = new<\/span> ArrayList<>();\r\nSystem.out.println(list.isEmpty()); \/\/ Outputs: true<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          contains(Object o)<\/code> Method:<\/h4>\n\n\n\n
                          Checks if the ArrayList contains the specified element.<\/p>\n\n\n\n
                          Syntax<\/strong>:<\/p>\n\n\n
                          boolean<\/span> contains<\/span>(Object o)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<String> list = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>));\r\nSystem.out.println(list.contains(\"B\"<\/span>)); \/\/ Outputs: true<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          size()<\/code> Method:<\/h4>\n\n\n\n
                          Returns the number of elements in the ArrayList.<\/p>\n\n\n\n
                          Syntax<\/strong>:<\/p>\n\n\n
                          int<\/span> size<\/span>()<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<String> list = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>));\r\nSystem.out.println(list.size()); \/\/ Outputs: 3<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          ArrayList’s subList(int fromIndex, int toIndex)<\/code> Method<\/h3>\n\n\n\n
                          The subList()<\/code> method returns a view of the portion of the list between the specified indices. It’s worth noting that the returned sublist is backed by the original list, meaning changes in the sublist will reflect in the original list and vice-versa.<\/p>\n\n\n\n
                          Syntax<\/strong>:<\/p>\n\n\n
                          List<E> subList<\/span>(int<\/span> fromIndex, int<\/span> toIndex)<\/span><\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Example<\/strong>:<\/p>\n\n\n
                          ArrayList<String> list = new<\/span> ArrayList<>(Arrays.asList(\"A\"<\/span>, \"B\"<\/span>, \"C\"<\/span>, \"D\"<\/span>, \"E\"<\/span>));\r\nList<String> subList = list.subList(1<\/span>, 4<\/span>);\r\nSystem.out.println(subList); \/\/ Outputs: [B, C, D]<\/span>\r\n\r\nsubList.set(0<\/span>, \"X\"<\/span>);\r\nSystem.out.println(list); \/\/ Outputs: [A, X, C, D, E]<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                          The indices are inclusive of the starting index (fromIndex<\/code>) and exclusive of the ending index (toIndex<\/code>), meaning the element at the starting index is included, but the element at the ending index is not.<\/p>\n\n\n\n
                          Best Practices when using ArrayList<\/h2>\n\n\n\n
                          ArrayList<\/code> is one of the most popular and versatile data structures in Java. When using it, there are some best practices that can ensure smooth and efficient operations, as well as prevent common pitfalls.<\/p>\n\n\n\n
                          Avoiding Null Elements: The Problems and Solutions<\/h3>\n\n\n\n
                          Problems<\/strong>:<\/p>\n\n\n\n
                            \n
                          • NullPointerException<\/strong>: This is one of the most common runtime exceptions in Java. When you try to invoke a method on a null object, it results in this exception.<\/li>\n\n\n\n
                          • Inconsistent Behavior<\/strong>: When you use nulls, operations like sorting can become unpredictable. For example, sorting an ArrayList containing nulls can lead to a NullPointerException<\/code>.<\/li>\n\n\n\n
                          • Complexity in Business Logic<\/strong>: Nulls can complicate business logic since you constantly need to check for null values before processing the elements.<\/li>\n<\/ul>\n\n\n\n
                            Solutions<\/strong>:<\/p>\n\n\n\n
                              \n
                            • Use Optional<\/strong>: Introduced in Java 8, Optional<\/code> can be used to represent a value that might be absent without relying on null.<\/li>\n\n\n\n
                            • Prevent Adding Nulls<\/strong>: Before adding elements to the list, always check for null and decide on a strategy (skip, replace with a default value, or throw an exception).<\/li>\n\n\n\n
                            • Use Null Object Pattern<\/strong>: Instead of using null, use a default instance of the object that represents an “empty” or “default” state.<\/li>\n<\/ul>\n\n\n\n
                              Using Generics for Type Safety<\/h3>\n\n\n\n
                              Benefits<\/strong>:<\/p>\n\n\n\n
                                \n
                              • Compile-Time Type Checking<\/strong>: Generics ensure that the type of elements you add to the ArrayList<\/code> is checked at compile time, preventing potential ClassCastException<\/code> at runtime.<\/li>\n\n\n\n
                              • Readable and Maintainable Code<\/strong>: Generics add clarity to your code, making it more readable and maintainable.<\/li>\n<\/ul>\n\n\n\n
                                Practice<\/strong>:<\/p>\n\n\n
                                \/\/ Without generics (not recommended)<\/span>\r\nArrayList list = new<\/span> ArrayList();\r\nlist.add(\"string\"<\/span>);\r\nlist.add(123<\/span>); \/\/ No compile-time error but can lead to issues later<\/span>\r\n\r\n\/\/ With generics (recommended)<\/span>\r\nArrayList<String> stringList = new<\/span> ArrayList<>();\r\nstringList.add(\"string\"<\/span>);\r\n\/\/ stringList.add(123); \/\/ Compile-time error<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                Minimizing Resizing Operations for Performance<\/h3>\n\n\n\n
                                Understanding Dynamic Resizing<\/strong>: When an ArrayList<\/code> grows beyond its current capacity, it gets resized. Typically, a new array is created, and the old data is copied to the new array, which can be an expensive operation.<\/p>\n\n\n\n
                                Best Practices<\/strong>:<\/p>\n\n\n\n
                                  \n
                                • Initialize with Proper Capacity<\/strong>: If you have a rough estimate of the number of elements that the list will hold, initialize the ArrayList<\/code> with that capacity.<\/li>\n<\/ul>\n\n\n
                                  ArrayList<String> list = new<\/span> ArrayList<>(100<\/span>); \/\/ Initial capacity of 100<\/span><\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    \n
                                  • Trim to Size<\/strong>: If the ArrayList<\/code> has grown and shrunk multiple times and you know you won’t be adding more elements, you can trim it to its current size to free up memory.<\/li>\n<\/ul>\n\n\n
                                    list.trimToSize();<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    In conclusion, adopting these best practices when working with ArrayList<\/code> can prevent common pitfalls, boost performance, and ensure that your code remains maintainable and robust.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                    Introduction Brief about the Java Collections Framework The Java Collections Framework (JCF) is a crucial and comprehensive set of classes and interfaces in Java’s standard library, designed explicitly for creating and manipulating collections of objects. These collections are essentially data structures that allow us to organize, store, and manage data efficiently. The JCF was introduced […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5,4],"tags":[],"class_list":["post-1380","post","type-post","status-publish","format-standard","category-java","category-programming-languages","entry"],"yoast_head":"\nJava ArrayList: From Iteration to Custom Objects<\/title>\n<meta name=\"description\" content=\"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Java ArrayList: From Iteration to Custom Objects\" \/>\n<meta property=\"og:description\" content=\"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-09-14T12:51:12+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-14T12:51:18+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"15 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Java ArrayList: From Iteration to Custom Objects\",\"datePublished\":\"2023-09-14T12:51:12+00:00\",\"dateModified\":\"2023-09-14T12:51:18+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/\"},\"wordCount\":3305,\"commentCount\":0,\"articleSection\":[\"Java\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/\",\"name\":\"Java ArrayList: From Iteration to Custom Objects\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-09-14T12:51:12+00:00\",\"dateModified\":\"2023-09-14T12:51:18+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/java-arraylist-from-iteration-to-custom-objects\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Java ArrayList: From Iteration to Custom Objects\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Java ArrayList: From Iteration to Custom Objects","description":"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/","og_locale":"en_US","og_type":"article","og_title":"Java ArrayList: From Iteration to Custom Objects","og_description":"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)","og_url":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/","article_published_time":"2023-09-14T12:51:12+00:00","article_modified_time":"2023-09-14T12:51:18+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"15 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Java ArrayList: From Iteration to Custom Objects","datePublished":"2023-09-14T12:51:12+00:00","dateModified":"2023-09-14T12:51:18+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/"},"wordCount":3305,"commentCount":0,"articleSection":["Java","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/","url":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/","name":"Java ArrayList: From Iteration to Custom Objects","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-09-14T12:51:12+00:00","dateModified":"2023-09-14T12:51:18+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"ArrayList is one of the most popular implementations of the List interface provided by the Java Collections Framework (JCF)","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/java-arraylist-from-iteration-to-custom-objects\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Java ArrayList: From Iteration to Custom Objects"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1380","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1380"}],"version-history":[{"count":5,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1380\/revisions"}],"predecessor-version":[{"id":1385,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1380\/revisions\/1385"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1380"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1380"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1380"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}