Introduction To Arrays in Java

What is an Array?

An array is a Linear Data Structure that consists of homogenous elements. The elements are stored at contiguous memory locations.

The elements within the array can be accessed using Indices, the first element is stored at the 0th index and the second element at the first Index.

Need of an Array

The whole idea of arrays is to have a consecutive set of memory locations that hold a homogenous set of values.
Arrays can also help in reducing the number of variables that you have to use to hold a lot of values with respect to the same homogenous type.
Arrays will help you to hold fine-grained, not only primitive values but can also help you to hold data of type objects wherein the homogeneity is maintained based on the object type that it actually refers to.

Setting Up an Array

Now, Let’s dive into the usage of arrays.

1. Declaration

There are two ways to declare an array -

Syntax - datatype arrayname[];

Syntax - datatype[] arrayname;

Example - int arr[]; // array of integer type

boolean[] arr; // array of boolean type

2. Initialization

Again there are multiple ways to initialize an array. We'll see the main ones here, but this article covers arrays initialization thoroughly.

Let's begin with an easy way:

int[] anArray = new int[10];

Note that in the initialization of the array size must be declared. The size of an array is usually fixed.

Here, the array initialized above is of integer type with size 10 which means it consists of 10 integer type elements in a contiguous manner indexed 0-9.

Currently, the array consists of default values of integer type i.e 0 at all indexes.

Another way of initializing an array is by using curly braces {} without declaring array size.

int[] anArray = new int[]{4,2,76,23};

int[] anArray = {4,2,76,23};

3. Representation

Int arr[] = new int[4];

23 45 1 19

0 1 2 3

4. Accessing Elements

Let's now see how to access the elements of an array. We can achieve this by using an index.

For example,

anArray[0] = 10;

System.out.println(anArray[0]); // 10

Note how we are using indices to access the array cells. The number between the brackets is the specific index of the array we want to access.

When accessing a cell, if the passed index is negative or goes beyond the last cell, Java will throw an ArrayIndexOutOfBoundException.

We should be careful not to use a negative index, or an index greater than or equal to the array size.

5. Traversing array elements

Accessing elements one by one can be useful, but we might want to iterate through an array. Let's see how we can achieve this.

The first way is to use the for loop:

int[] array = new int[] {1, 4, 3, 8, 5};

for (int i = 0; i <array.length; i++) {

System.out.println(array[i]);

}

This should print elements of the array to the console. As we can see we made use of the length property. This is a public property giving us the size of the array.

We can also loop over arrays using the foreach loop:

int[] array = new int[] {1, 2, 99, 4, 5};

for (int element :array) {

System.out.println(element);

}

This example is equivalent to the previous one, but we got rid of the indices boilerplate code. A foreach loop is an option when:

we don't need to modify the array (putting another value in an element won't modify the element in the array)
we don't need the indices to do something else

Applications of arrays

An array is used to maintain extensive data under a single variable name. Elements can be often accessed easily using indexes.
An array is used in CPU Scheduling
An array data structure is used to implement other Data Structures like Linked List, Stacks, and Queues.
Lastly, Array is used for sorting elements using different sorting Algorithms like Bubble Sort, Selection Sort, and Merge Sort.

Conclusion

In this article, we learned the basic introduction of arrays furthermore their usage.

created by Vaishnavi Chaurasia @TechInfinity