How to Use Arraylist Effectively in Java

1.ArrayList Constructors

The ArrayList class supports three constructors.

Arraylist()

This constructor builds an empty list.

ArrayList(Collection<? extends E> c)

This constructor creates a list containing the elements of the specified collection. Note that E is the notation for the type of an element in a collection.

ArrayList(int initialCapacity)

This constructor creates an empty list with the specified initial capacity.

For example, if you want to create an empty array list of Strings then you would do the following:

ArrayList<String> list = new ArrayList<String>();

If you want to create an array list with initial capacity, then you should do the following:

ArrayList<Integer> list = new ArrayList<Integer>(7);

Note that ArrayList class supports only object types and not primitive types.

2. ArrayList common methods

Here are some of the most useful ArrayList methods.

Adding elements to the list
- boolean add(Element e)
  Adds the specified element to the end of this list.
- void add(int index, Element e)
  Adds the specified element at the specified position in the list.

Removing elements from the list
- void clear()
  Removes all the elements from the list.
- E remove(int index)
  Removes the element at the specified position in the list.
- protected void removeRange(int start, int end)
  Removes from the list all the elements starting from index start (included) until index end (not included).

Getting elements from the list
- E get(int index)
  Returns the element at the specified position.
- Object[] toArray()
  Returns an array containing all the elements of the list in proper sequence.

Setting an element
- E set(int index, E element)
  Replaces the element at the specified position with the specified element.

Searching elements
- boolean contains(Object o)
  Returns true if the specified element is found in the list.
- int indexOf(Object o)
  Returns the index of the first occurrence of the specified element in the list. If this element is not in the list, the method returns -1.
- int lastIndexOf(Object o)
  Returns the index of the last occurrence of the specified element in the list. If this element is not in the list, the method returns -1.

Iterating the arraylist
- Iterator iterator()
  Returns an iterator over the elements in the list.
- ListIterator listIterator()
  Returns a list iterator over the elements in this list.

Checking if the list is empty
- boolean isEmpty()
  Returns true if the list does not contain any element.

Getting the size of the list
- int size()
  Returns the length of the list (the number of elements contained in the list).

Those were the most commonly used methods of java.util.ArrayList. For further details for each method or for other methods that are not mentioned in this section, you can have a look at official java api.

3. Examples of using ArrayList in Java

Create a java class named ArrayListExamples.java with the following code:

ArrayListExamples.java

01
import java.util.*;

02
 
03
public class ArrayListExamples {

04
 
05
    public static void main(String args[]) {

06
        // Creating an empty array list

07
        ArrayList<String> list = new ArrayList<String>();

08
 
09
        // Adding items to arrayList

10
        list.add("Item1");

11
        list.add("Item2");

12
        list.add(2, "Item3"); // it will add Item3 to the third position of

13
                                // array list

14
        list.add("Item4");

15
 
16
        // Display the contents of the array list

17
        System.out.println("The arraylist contains the following elements: "

18
                + list);

19
 
20
        // Checking index of an item

21
        int pos = list.indexOf("Item2");

22
        System.out.println("The index of Item2 is: " + pos);

23
 
24
        // Checking if array list is empty

25
        boolean check = list.isEmpty();

26
        System.out.println("Checking if the arraylist is empty: " + check);

27
 
28
        // Getting the size of the list

29
        int size = list.size();

30
        System.out.println("The size of the list is: " + size);

31
 
32
        // Checking if an element is included to the list

33
        boolean element = list.contains("Item5");

34
        System.out

35
                .println("Checking if the arraylist contains the object Item5: "

36
                        + element);

37
 
38
        // Getting the element in a specific position

39
        String item = list.get(0);

40
        System.out.println("The item is the index 0 is: " + item);

41
 
42
        // Retrieve elements from the arraylist

43
 
44
        // 1st way: loop using index and size list

45
        System.out

46
                .println("Retrieving items with loop using index and size list");

47
        for (int i = 0; i < list.size(); i++) {

48
            System.out.println("Index: " + i + " - Item: " + list.get(i));

49
        }

50
 
51
        // 2nd way:using foreach loop

52
        System.out.println("Retrieving items using foreach loop");

53
        for (String str : list) {

54
            System.out.println("Item is: " + str);

55
        }

56
 
57
        // 3rd way:using iterator

58
        // hasNext(): returns true if there are more elements

59
        // next(): returns the next element

60
        System.out.println("Retrieving items using iterator");

61
        for (Iterator<String> it = list.iterator(); it.hasNext();) {

62
            System.out.println("Item is: " + it.next());

63
        }

64
 
65
        // Replacing an element

66
        list.set(1, "NewItem");

67
        System.out.println("The arraylist after the replacement is: " + list);

68
 
69
        // Removing items

70
        // removing the item in index 0

71
        list.remove(0);

72
 
73
        // removing the first occurrence of item "Item3"

74
        list.remove("Item3");

75
 
76
        System.out.println("The final contents of the arraylist are: " + list);

77
 
78
        // Converting ArrayList to Array

79
        String[] simpleArray = list.toArray(new String[list.size()]);

80
        System.out.println("The array created after the conversion of our arraylist is: "

81
                        + Arrays.toString(simpleArray));

82
    }

83
}

In the above code, we can see that many ArrayList usage cases are covered. Adding elements to the list using 2 different methods, removing elements, getting the size of the list, checking if the list is empty, checking if a specific element is contained to the list. Also, 3 different ways are presented for retrieving the elements of a list. Finally, we show how to convert an ArrayList to Array.

Output:

The arraylist contains the following elements: [Item1, Item2, Item3, Item4]
The index of Item2 is: 1
Checking if the arraylist is empty: false
The size of the list is: 4
Checking if the arraylist contains the object Item5: false
The item is the index 0 is: Item1
Retrieving items with loop using index and size list
Index: 0 - Item: Item1
Index: 1 - Item: Item2
Index: 2 - Item: Item3
Index: 3 - Item: Item4
Retrieving items using foreach loop
Item is: Item1
Item is: Item2
Item is: Item3
Item is: Item4
Retrieving items using iterator
Item is: Item1
Item is: Item2
Item is: Item3
Item is: Item4
The arraylist after the replacement is: [Item1, NewItem, Item3, Item4]
The final contents of the arraylist are: [NewItem, Item4]
The array created after the conversion of our arraylist is: [NewItem, Item4]

As we see in the output, the results are complied with what we described in the previous section.

SOURCE:

Best training institute for java in chennai

Java arraylist example