ArrayList is a class belongs to collections framework. For doing multiple works with static array is time consuming. Most important thing, arrays are generally static in nature which is not well for memory management. For overcoming these problems Java developers introduced ArrayList.

Note: if you familiar with C/C++ then you have might work with array and linked list. Why does we use Linked List over array ? because it support dynamic programming but arrays generally are static.

Let’s understand Integer type ArrayList

import java.util.*;
 
class arrayListInt{
    public static void main(String[] args){
        ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(20);
        arr1.add(30);
        arr1.add(60);
        arr1.add(-90);
 
        // display whole array-list
        System.out.println(arr1);
 
        // deletion of elemenets from array-list using it’s index
        arr1.remove(2);
 
        // display after first deletion
        System.out.println(arr1);
       
        // delete index ‘0’ element from array-list
        arr1.remove(0);
        System.out.println(arr1);
 
    }
}
output
Note: add() method we can add’s new element into ArrayList. Using remove(n) => n(index number) method we can remove(delete) element from ArrayList.

Let’s understand String type ArrayList

import java.util.*;
 
class arrayListString{
    public static void main(String[] args){
        ArrayList <String> str = new ArrayList<>();
        // adding new elements into array-list
        str.add(“alok”);
        str.add(“mohan”);
        str.add(“asha”);
        str.add(“raju”);
        str.add(“rekha”);
 
        // display whole array-list
        System.out.println(str);
 
        // deletion of elemenets from array-list using it’s index
        str.remove(“asha”);
 
        // display after first deletion
        System.out.println(str);
        
        // delete index ‘0’ element from array-list
        str.remove(“rekha”);
        System.out.println(str);
 
        str.remove(0);
        System.out.println(str);
    }
}
output
Note: in String type ArrayList we can remove element by it’s name or even with index. From above code, we first generate String type ArrayList and after that we removes elements by it’s name[“asha”,”rekha”].

How does ArrayList manages memory efficiently?

We can get the size/length of ArrayList using method size() . let’s see if we adding new element into ArrayList or remove existing element from ArrayList, then how it’s size changed?

Let’s use Integer and String type ArrayList one by one.

import java.util.*;
 
class arrLstInt{
    public static void main(String[] args){
        ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(20);
        arr1.add(30);
        arr1.add(60);
        arr1.add(-90);
 
        System.out.println(arr1);
        System.out.println(“array size is “+arr1.size());
        arr1.remove(2);
        System.out.println(arr1);
         System.out.println(“array size is “+arr1.size());
      
        arr1.remove(0);
        System.out.println(arr1);
         System.out.println(“array size is “+arr1.size());
      
    }
}
output
import java.util.*;
 
class arrListStr{
    public static void main(String[] args){
        ArrayList <String> str = new ArrayList<>();
        // adding new elements into array-list
        str.add(“alok”);
        str.add(“mohan”);
        str.add(“asha”);
        str.add(“raju”);
        str.add(“rekha”);
 
        System.out.println(str);
        System.out.println(“string size “+str.size());
        str.remove(“asha”);
        System.out.println(str);
        System.out.println(“string size “+str.size());
      
         str.remove(“rekha”);
        System.out.println(str);
        System.out.println(“string size “+str.size());
      
        str.remove(0);
        System.out.println(str);
        System.out.println(“string size “+str.size());
      
 
    }
}
output

Other methods of ArraylIst

Here we will see some methods like max(), min(), sort() and so on. Let’s dig in…

  1. Write a code, which find maximum and minimum element from an Integer and String ArrayList.
// Integer Array
import java.util.*;
 
class arrMaxMin{
    public static void main(String[] args){
        ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(20);
        arr1.add(30);
        arr1.add(60);
        arr1.add(-90);
 
        System.out.println(“array is “+arr1);
        System.out.println(“array maximum element is “+Collections.max(arr1));
        System.out.println(“array minimum element is “+Collections.min(arr1));
       
          }
}
output

let’s see another for string implementation

import java.util.*;
 
class StrarrMaxMin{
    public static void main(String[] args){
        ArrayList <String> str = new ArrayList<>();
        // adding new elements into array-list
        str.add(“bill gates”);
        str.add(“linus torvalds”);
        str.add(“steve jobs”);
        str.add(“sundar pichai”);
        str.add(“satya nadella”);
 
        System.out.println(“array is “+str);
        System.out.println(“array maximum element is “+Collections.max(str));
        System.out.println(“array minimum element is “+Collections.min(str));
       
          }
}
output

2. Write a code, to calculate the average of elements in ArrayList.

Note: for doing this operations we need to access ArrayList elements using it’s index. get(n) method is used for this purpose, n = index.
import java.util.*;
 
class arrLstIntavg{
    public static void main(String[] args){
          ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(20);
        arr1.add(30);
        arr1.add(60);
        arr1.add(-90);
 
        System.out.println(“array is “+arr1);
        int n,sum=0;
        for(int i=0;i<arr1.size();i++){
           n= arr1.get(i);
           sum=n+sum;
        }
        int avg=sum/arr1.size();
        System.out.println(“average is “+avg);
    }
}
output

3. Write a code, to sort an integer and string type ArrayList in ascending order.

Note: for doing ascending order we need to use Collection class’s sort() method. For Descending order use can use Collections.sort(arrayName, Collections.reverseOrder()).
// Integer arrayList sort ascending
import java.util.*;
 
class arrListasc{
    public static void main(String[] args){
          ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(200);
        arr1.add(30);
        arr1.add(-6);
        arr1.add(-90);
 
        System.out.println(“array is “+arr1);
        Collections.sort(arr1);
        System.out.println(“after sort array is “+arr1);
       
    }
}
output

let’s see another implementation

// // Integer arrayList sort descending
import java.util.*;
 
class arrListdsc{
    public static void main(String[] args){
            ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(200);
        arr1.add(30);
        arr1.add(-6);
        arr1.add(-90);
 
        System.out.println(“array is “+arr1);
        Collections.sort(arr1, Collections.reverseOrder());
        System.out.println(“after reverse array is “+arr1);
    }
}
output

4. Write a code, to convert an arraylist into normal array.

// Integer ArrayList to normal array
import java.util.*;
 
class arrListToArray{
    public static void main(String[] args){
 ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(200);
        arr1.add(30);
        arr1.add(-6);
        arr1.add(-90);
        System.out.println(“arraylist is “+arr1);
 
        // declaring array ‘marr’
        Integer marr[] = new Integer[arr1.size()];
        /* converting ArrayList ‘arr1’ to normal array ‘marr’
        using toArray() method
        */
        arr1.toArray(marr);
 
        System.out.println(“normal array is “);
        int i=0;
        while(i<5){
            System.out.println(“index is -> “+i);
            System.out.println(“element is -> “+marr[i]);
            i++;
        }
    }
}
     
output
let’s convert a string arraylist into normal array.
import java.util.*;
 
class StrarrListToArray{
    public static void main(String[] args){
        ArrayList <String> str = new ArrayList<>();
        // adding new elements into array-list
        str.add(“bill gates”);     
        str.add(“linus torvalds”);
        str.add(“steve jobs”);
        str.add(“sundar pichai”);
        str.add(“satya nadella”);
 
        System.out.println(“String ArrayList is -> “+str);
       
        // declaring String normal array
        String strArr[] = new String[str.size()];
 
        // converting String ArrayList ‘str’ into normal array ‘strArr’
        str.toArray(strArr);
 
        System.out.println(“normal string array is: “);
        for(int i=0;i<str.size();i++){
            System.out.println(“index is -> “+i);
      
            System.out.println(“element is -> “+strArr[i]);
        }
    }
}
output

5. Write a code, which checks an element present or not in Integer/String type ArrayList.

// Integer arraylist
import java.util.*;
 
class IntArrexist{
    public static void main(String[] args){
             ArrayList <Integer> arr1 = new ArrayList<>();
        // adding new elements into array-list
        arr1.add(10);
        arr1.add(200);
        arr1.add(30);
        arr1.add(-6);
        arr1.add(-90);
 
        System.out.println(“array is “+arr1);
 
        System.out.println(“Enter element to find: “);
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if(arr1.contains(n)){
            System.out.println(“element found!!”);
        }
    }
}
output

Let’s implement this for string arraylist.

// String arraylist
import java.util.*;
 
class StrArrexist{
    public static void main(String[] args){
         ArrayList <String> str = new ArrayList<>();
        // adding new elements into array-list
        str.add(“tony”);     
        str.add(“thor”);
        str.add(“steve”);
        str.add(“captain”);
        str.add(“daredevil”);
 
        System.out.println(“String ArrayList is -> “+str);
 
        System.out.println(“enter element to find: “);
        Scanner sc = new Scanner(System.in);
        String n = sc.next();
        System.out.println(“search string is “+n);
 
        if(str.contains(n)){
            System.out.println(“string element found!!”);
        }     
    }
}
output

6. Write a code, which adds new element into String arraylist.

import java.util.ArrayList;
 
public class StrLstAdd {
    public static void main(String[] args) {
        ArrayList <String> arr = new ArrayList<>();
        arr.add(“Java”);
        arr.add(“python”);
        arr.add(“C”);
        arr.add(“PHP”);
 
        System.out.println(“arraylist -> “+arr);
 
        arr.add(0,”javascript”);
        System.out.println(“after arraylist -> “+arr);
 
        arr.add(3,”dart”);
        System.out.println(“after arraylist -> “+arr);
    }
}
output

Note: add(m,n) method m-> index, n-> element . This operations also same for Integer arraylist.

download notes

download code.zip