Skip to main content

Array List - Collections Framework in Java - DSA

Gist:

An array list can store individual objects by following insertion order, here the initial capacity is 10 by default but can be modified as per the requirement, once the array list reaches its load factor then internal all the elements of the current array is copied to a new array with the new capacity and the reference variable will now be referring to this new array list and the old array will be dealt by the garbage collector.

Hierarchical order



Type of constructors

  • Empty argument constructor or the default constructor is the same as invoking any other object here a new ArrayList is created with a default size of 10. Below is the most commonly used constructor by beginners and others alike.

    ArrayList array = new ArrayList();
    //array has a capacity of 10

  • The default constructor above will allot only 10 slots but if you want the initial size to be 20 or 1000 you can do so with the following constructor this is ideal when you know the number of entries expected, compared to the default here you will save a lot of performance. since this part is important I will stretch it with an example.

    If you are preparing to insert 100 inputs by calling the default constructor, then every time the ArrayList reaches its capacity it will clone itself and grow to a certain capacity and this internal task will take a toll on your performance so instead if you already set the capacity while creating the array list this internal process of growing can be avoided thus saving a lot of performance and time.

    ArrayList arrayOfPages = new ArrayList(380);
    //array has a capacity of 380

  • Conversion of other Collections like LinkedList, Vector, etc...to an ArrayList is possible with the following constructor.

    ArrayList arraysFromVector = new ArrayList( VariableNameOfTheCollection );
    //here any collection will be converted into an ArrayList

Important Points

  • Is Dynamically Growable and Shrinkable.
  • Heterogeneous Objects are allowed.
  • The initial capacity is 10
  • Load Factor is 0.75
  • Order of insertion is preserved
  • We can also use generic data-type such that the array acts like a homogenous.

Implementing Interfaces

  • Serializable
  • Cloneable
  • RandomAccess
  • Iterable <E>
  • Collection <E>
  • RandomAccess <E>

Commenly Used methods from List and the respective base classes.

  • .add(element) -> add an element in the last.
  • .add(Index, element) -> add an element at the specified index.
  • .addAll(Collection x) -> adds all the elements of the collection x
  • .addAll(Index , Collection x) -> adds all the elements of the collection x from the specified index.
  • .set(index,element) -> change an element at the specified index.
  • .get(index) -> Retreve the element from the requested index.
  • .contains(object) -> Retreves a boolean value if the element is available..
  • .indexOf(object) -> Retreves index value if the element is available or -1.
  • .remove(object) -> to remove an element at the requested position.
  • .sort() -> Sorts the collection.
  • .subList(startIndex, endIndex) -> returns an array list with values from the range of index.
  • .trimToSize() -> The capacity of the array will be set to the size of the array to save memory.
Pros Cons
Ideal if a lot of index-based retrieval or update operations will be performed. If elements need to be added or removedat an index the entire array elements will be shifted internally.
Can be traversed through both directions. Java ArrayList class is non-synchronized.
Can hold duplicate elements.
Can take hold of null.
Once the load factor is met then the capacity will be increased by (current capacity *3/2)+1
Labels:

Comments

Post a Comment

Popular posts from this blog

Introduction to Primitives - Java

2. Overview: There are eight primitive data types byte, short, int, long, float, double boolean, char. These eight data types store values as raw instead of Objects these primitives help to save memory to a great extent and simplify other processes as they are directly stored in the stack. Data Type Size(in bits) Minimum Range Maximum Range byte 8 -128 127 short 16 -32768 32767 int 32 -2147483648 2147483647 long 64 -9223372036854775808 9223372036854775807 float 32 -3.4e38 to -1.4e-45 1.4e-45 to 3.4e38 double 64 -1.8e308 to -4.9e-324 4.9e-324 to 1.8e308 boolean 1 - - char 16 space 65535 byte A byte has the capacity of 8 bits or 1 byte and it can store numbers between -2 7 and 2 7 -1 or simply -128 to 127. This is very useful while deali...
Post a Comment
Read more

Chocolate Feast - Problem Solving - Hacker Rank Solution.

The expectation is to find the total number of choclate one can consume by taking full advantage of the offer, Here there are 3 inputs n which holds the value of initial amount of money for buying choclate, c is the cost price of each candy if paid by cash and m is the exchange rate for the candy. Inputs n Initial cash to buy candy. c Coast of each candy if paid by cas.h m Exchange rate for a new candy in offer. The initial count of choclate will be the cash / coast and the wrappers in hand will be the same value of choclate, and from there we loop through until the wrap count is less than the exchange rate, inside the loop the choclate count will still hold the same fourmula as before but divided with exchange rate. The wrap count is the tricky part... the wrap will be wrap/ exchange rate(the no. choclate) + the remainder of this division(THIS IS VERY IMPORTANT) because for example if the count of wrapper is 3 and the exchange rate is 2 you can only buy 1 c...
Post a Comment
Read more

Collection Interface - Java Collections Framework - DSA

Most people consider the collection as the root interface of Collections Framework and it is true to a great extent but another part of Collections Framework is Map Interface, we will see that later, Most Common methods which are applicable to all collections are defined in this interface for example add() to add an element, size() to get the size and much more, below is a table of most common methods. Hierarchey of the Collection Interface. The Parent of Collection Interface is Iterator Interface and the Collection is base class for List Interface, Set Interface and Queue Interface, the respective classes which impliments either of the sub classes will also implement the defined methods from the Collection Interface, below are some of the commonly used methods. Defined Methods: Method Description add() This method returns a Boolean value true if it inserts the specified element in this collection....
Post a Comment
Read more