Fixed size ArrayList java
In Java programming, there are two ways to create an array.
An Array can contain both primitive data types or objects of a class depending on the definition of the array. But it has a fixed size. Example// Importing the required libraries import java.util.Arrays; class Array { public static void main(String args[]) { /* ...........Array............. */ // Fixed size. // Cannot add more than 3 elements. int[] arr = new int[3]; arr[0] = 5; arr[1] = 6; arr[2] = 10; // Printing System.out.println(Arrays.toString(arr)); } }
An ArrayList can’t be created for primitive data types. It only contains an object. It has the ability to grow and shrink dynamically.
Example// Importing required libraries
import java.util.ArrayList;
class Array_List
{
public static void main(String args[])
{
/*............ArrayList..............*/
// Variable size.
// Can add more elements.
ArrayList The ArrayList ensureCapacity() method increases the capacity of the given ArrayList instance, if necessary, to ensure that it can hold at least the number of items specified by the method argument minCapacity. We need to use ensureCapacity() method in cases when there is a huge number of add() operations in the ArrayList. In such cases, ArrayList will be frequently resized which is an expensive operation. 1. Syntaxpublic void ensureCapacity(int minCapacity)If the value of minCapacity is less than 10 which is the default capacity of ArrayList, then the capacity ensured will be 10. 2. Why ArrayList Resizing is Expensive?Java ArrayList internally uses a backing array object elementData which is used to store the list items. All ArrayList methods operate on this elementData and items stored in it. public class ArrayListThis is the reason why ArrayList is an ordered collection and provides index-based access to items. Note that Arrays are fixed-size collections whereas ArrayList grows in runtime as soon as the backing array elementData is full and more elements are added to the list. Increasing the size of elementData array is called resizing. This resizing is done in two steps:
So basically, before adding any new item to the ArrayList with add() method, ArrayList performs a check whether there is any space left in the backing array using ensureCapacity() method. If there is any space available in the backing array then the new element is added into the array; else a new backing array is created first. Read More: ArrayList Sourcecode 3. ArrayList ensureCapacity() ExampleJava program to use ensureCapacity() method to increase the size of an ArrayList after its initialization. In given example, we have first created an ArrayList with size 2. Lets suppose we want to add 20 more elements to it, then during the addition resizing will happen a few times. First-time resizing will grow the list size to 10. Then subsequent add() operations will cause the array to resize a few more times. To avoid this resizing many times, we can call ensureCapacity() method with a size of 25. This will make enough room in the array to store all the additional 20 items that we are going to add. It improves the overall performance of the whole program. public class ArrayListExample { public static void main(String[] args) { ArrayList<> list = new ArrayList<>(2); list.add("A"); list.add("B"); System.out.println(list); list.ensureCapacity(25); list.add("C"); list.add("D"); list.add("E"); System.out.println(list); } }Program output. [A, B] [A, B, C, D, E]Happy Learning !! Read More: A Guide to Java ArrayList Let us know if you liked the post. That’s the only way we can improve. public: static System::Collections::ArrayList ^ FixedSize(System::Collections::ArrayList ^ list); public static System.Collections.ArrayList FixedSize (System.Collections.ArrayList list); static member FixedSize : System.Collections.ArrayList -> System.Collections.ArrayList Public Shared Function FixedSize (list As ArrayList) As ArrayList ArrayList An ArrayList wrapper with a fixed size. ExamplesThe following code example shows how to create a fixed-size wrapper around an ArrayList. using namespace System; using namespace System::Collections; void PrintValues( IEnumerable^ myList, char mySeparator ); int main() { // Creates and initializes a new ArrayList. ArrayList^ myAL = gcnew ArrayList; myAL->Add( "The" ); myAL->Add( "quick" ); myAL->Add( "brown" ); myAL->Add( "fox" ); myAL->Add( "jumps" ); myAL->Add( "over" ); myAL->Add( "the" ); myAL->Add( "lazy" ); myAL->Add( "dog" ); // Create a fixed-size wrapper around the ArrayList. ArrayList^ myFixedSizeAL = ArrayList::FixedSize( myAL ); // Display whether the ArrayLists have a fixed size or not. Console::WriteLine( "myAL {0}.", myAL->IsFixedSize ? (String^)"has a fixed size" : "does not have a fixed size" ); Console::WriteLine( "myFixedSizeAL {0}.", myFixedSizeAL->IsFixedSize ? (String^)"has a fixed size" : "does not have a fixed size" ); Console::WriteLine(); // Display both ArrayLists. Console::WriteLine( "Initially," ); Console::Write( "Standard :" ); PrintValues( myAL, ' ' ); Console::Write( "Fixed size:" ); PrintValues( myFixedSizeAL, ' ' ); // Sort is allowed in the fixed-size ArrayList. myFixedSizeAL->Sort(); // Display both ArrayLists. Console::WriteLine( "After Sort," ); Console::Write( "Standard :" ); PrintValues( myAL, ' ' ); Console::Write( "Fixed size:" ); PrintValues( myFixedSizeAL, ' ' ); // Reverse is allowed in the fixed-size ArrayList. myFixedSizeAL->Reverse(); // Display both ArrayLists. Console::WriteLine( "After Reverse," ); Console::Write( "Standard :" ); PrintValues( myAL, ' ' ); Console::Write( "Fixed size:" ); PrintValues( myFixedSizeAL, ' ' ); // Add an element to the standard ArrayList. myAL->Add( "AddMe" ); // Display both ArrayLists. Console::WriteLine( "After adding to the standard ArrayList," ); Console::Write( "Standard :" ); PrintValues( myAL, ' ' ); Console::Write( "Fixed size:" ); PrintValues( myFixedSizeAL, ' ' ); Console::WriteLine(); // Adding or inserting elements to the fixed-size ArrayList throws an exception. try { myFixedSizeAL->Add( "AddMe2" ); } catch ( Exception^ myException ) { Console::WriteLine( "Exception: {0}", myException ); } try { myFixedSizeAL->Insert( 3, "InsertMe" ); } catch ( Exception^ myException ) { Console::WriteLine( "Exception: {0}", myException ); } } void PrintValues( IEnumerable^ myList, char mySeparator ) { IEnumerator^ myEnum = myList->GetEnumerator(); while ( myEnum->MoveNext() ) { Object^ obj = safe_cast |