Java notes: Arrays

An array is a data structure which stores a fixed-size sequential collection of elements of the same data type. Every element in an array is of the same type.

In order to use an array in a program, a variable to reference the array and the array’s data type is required.

dataType [] arrayReferenceVariable;

or

dataType arrayReferenceVariable []; //correct but not preferred

Note that here no memory is allocated from the array.

At this point, the size of the array is not fixed.

arrayRefVar [index] = value;

For example,

sampleArray [3] = 12;

An array is the continuous memory space that contains values of its elements. The array variable contains the reference to the array.

arrayRefVar.length;

When an array is created, its elements are assigned the default value of 0 for numeric primitive data types, \u0000 for character data types, and false for boolean data type.

The elements of an array can be accessed through their index. The indices in an array range from 0 to arrayLength-1.

An initializer combines declaration, creation, and initialization of an array in one statement

double [] numArray = {23, 32, 1, 4, 45};

Note that the new operator was used to create the array. When you create an array using array initialier, you must make sure to include the declaration, creation, and initialization all in one line. The following would be a syntax error:

double [] numArray;
numArray = {23, 32, 1, 4, 45};

Arrays are processed using for loops for two main reasons:

1. As we know, all the elements in an array are of the same type. Therefore, they can be processed in the same fashion repeatedly using a for loop
2. We can find the size of an array using the arrayRefVar.length function. Therefore using a loop to traverse the length of a loop is a convenient option.

The foreach loops enables the user to traverse the array sequentially without having to use an index number. The loop variable should be of the same type as elements in the array.

Syntax:

for (elementType loopVar: arrayReferenceVariable){
}

For instance,

int [] num= {1,2,3,4,5}

for (int i : num){
System.out.println(i);
}

A foreach look can be read as “for each element i in num, do the following”

When the index of the array reaches beyond its fixed size during runtime, the ArrayOutOfBoundsException is thrown.

Ensure that the index does not go beyond arrayRefVar.length-1 or simply use a foreach loop.

When a programmer makes the error of assuming that the index of an array begins from 1 (and not 0).

Another off by one error arises when the programmer makes the following mistake.

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

Notice that the programmer has used <= instead of <.

Individual elements of the array have to copied to the new array.

Note that arrayVar1= arrayVar2 does not copy the elements of one array to the other. Using the statement only copies the reference one array to the other. So the two arrayRefVariables will point to the same array.

There are three ways to copy one array to another:

1. Using a loop to copy each element of array1 to array2

for (int i=0; i<array1.length; i++){
array2[i]= array1[i];
}

2. Using the static arraycopy function in the java.lang.System class

Syntax:
System.arraycopy(sourceArray, sourceStartingPos, targetArray, targetStartingPos, length);

Note that the target array must be declared prior to passing it to the arraycopy method. The targetArray created by the arraycopy method does not share the same reference with the sourceArray as the new array has an independent memory location.

3. Using clone class function.

Suppose you have two array reference variables arrayRef1 and arrayRef2. Both point to array1 and array 2 respectively. Now if we add the statement arrayRef2= arrayRef1, arrayRef2 no longer points to array two but instead point to where arrayRef1 is pointing i.e array1. The array that arrayRef2 previously pointed to (array2) is no longer referenced and is considered ‘garbage.’ The Java Virtual Machine automatically clears the garbage from the memory. This is known as garbage collection.

Syntax:
public void sampleMethod (int [] array){
}

Remember that the reference of the array is passed to the method. So any changes made to the array in the method, will be reflected in the original array.

printArray(new int [] {1,2,3,4,5});

The above array being passed to the printArray method is an anonymous array. There is no explicit reference variable of the array.

public static int[] returnArray (int [] array){
int [] newArray= new int[array.length];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}

When a method returns an array, it returns the reference of the array.

A variable number of arguments of the same type can be passed to a method and treated as an array.

Syntax:
type… varName

Only one variable-length parameter can be declared in a specific method.

Also, return type of a method cannot be a varargs type

package Array;

/**
 * Created by aarushi on 1/5/21.
 */
public class ArrayVarArgsSample {

    //method takes variable number of integer arguments
    public static void varargsSample (int ... sample){
        for(int i=0; i<sample.length; i++){
            System.out.print(sample[i]+ " ");
        }
        System.out.println();
    }

    public static void main (String [] args){
        varargsSample(1, 2 , 3, 4);
        varargsSample(new int[] {2,4});
        varargsSample(0);
    }
}

The execution time of linear search algorithm increases in proportion with size of the array.

The java.util.Arrays class contains several static methods which are used to carry out common array operations like searching, sorting, comparing, filling array elements, and return a strinf representation of an array.