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

Linked List in Java - Collections Framework- DSA

Gist: A Linked list is dynamic array where a group of object can be stored while following the insertion order and allow duplicates, the 2 type of linked list is singly and double linked lists, the default one is single linked list where the elements can be traversed only in forward direction this is because unlike array here the elements are stored at random locations and only the node of each element knows the address of the next element. A simple example would be our circut board here a point X may be connection to Y and Y connectioned to pont Z here the insertion order is preserved and we can know the next point only by following the signals from the previous point. Same as the example but in Linked list each element has 2 parts in singly linked list where 1 part is the node with the adress to the next node and the other which is the actua data of that element like a post letter the envelop has the address and inside the contents. but in doubly linked list there are 3 parts ...
Post a Comment
Read more

Designer PDF Viewer - HackerRank Problems

Difficulty: EASY Problem : The objective here is to find the size of the highlighted area, and we are given the size's of all the alphabets, we have to find the largest alphabet in the highlighted word and then calculate the size of the rectangle so if the tallest character is 3 then the size of the box will be 3 * number of characters given. Visual representation of the selection : abc def ghij Inputs An array with the sizes of all alphabets a-z in order. A String of highlighted words. Important points to note The array which holds the height of each character in ascending order which means the arrays 0th index will have the height of a 1st index will have the height of b and so on and so forth in the end the hight of z will be there so it's easy to locate each character. A String with the highlighted word. This means we have got the characters inside the rectangle, all we have to find is ...
Post a Comment
Read more

Naming Conventions in Java

Naming Conventions in Java As the movies are rated G, PG, U, A depending on the age restriction and by just gazing through the rating our parents decide the movie to watch together, or a book with diffrent labels to keep track of the sections and just by seeing them we know what they represent, the same labeling method has been introduced by Java team to diffrenciate variables, methods, classes, constants etc.. and we will be going through them all here. Type Naming Convention Example Variables Must start with a lower case and every other word capitalized int counter; Constants Must all be upper case and _ for diffrenciating every other word final int MAX_HEALTH = 100; Methods Must start with a lower case and every other word capitalized. can be distingiused from the variable by the () next to the method name void printNum(){..} Class Must start an upper case letter and every other word must ...
Post a Comment
Read more