Static Array in Java

In Java, array is the most important data structure that contains elements of the same type. It stores elements in contiguous memory allocation. There are two types of array i.e. static array and dynamic array. In this section, we will focus only on static array in Java.

Static Array

An array that is declared with the static keyword is known as static array. It allocates memory at compile-time whose size is fixed. We cannot alter the static array.

If we want an array to be sized based on input from the user, then we cannot use static arrays. In such a case, dynamic arrays allow us to specify the size of an array at run-time.

Static Array Example

For example, int arr[10] creates an array of size 10. It means we can insert only 10 elements; we cannot add a 11th element as the size of Array is fixed.

int arr[] = { 1, 3, 4 }; // static integer array
int* arr = new int[3]; // dynamic integer array

Advantages of Static Array

It has efficient execution time.
The lifetime of static allocation is the entire run time of the program.

Disadvantages of Static Array

In case more static data space is declared than needed, there is waste of space.
In case less static space is declared than needed, then it becomes impossible to expand this fixed size during run time.

Declaring a Static Array

The syntax to declare a static array is:

For example:

String[] suit = new String[] {
  "Japan", 
  "India", 
  "Austria", 
  "Dubai"  
};

We can also declare and initialize static array as follows:

String[] suit = {
  "Japan", 
  "India", 
  "Austria", 
  "Dubai"  
};

Static array can also be declared as a List. For example:

List suit = Arrays.asList(
  "Japan", 
  "India", 
  "Austria", 
  "Dubai"  
);

Static Array Java Program

StaticArrayExample.java

public class StaticArrayExample 
{
private static String[] array;
static 
{
array = new String[2];
array[0] = "Welcome to";
array[1] = "Javatpoint";
}
public static void main(String args[]) 
{
for(int i = 0; i < array.length; i++)
{
System.out.print(array[i] + " ");
}
}
}

Output:

Welcome to Javatpoint

Let's see another Java program.

StaticArrayExample.java

public class StaticArrayExample2 
{
//creates a static array of integer type
static Integer[] integerArray;
static 
{
integerArray = new Integer[] { new Integer(1), new Integer(2), new Integer(3), new Integer(4), new Integer(5)};
}
public static void main(String args[]) 
{
//loop iterate over static array    
for (int i = 0; i < integerArray.length; i++) 
{
//prints array elements    
System.out.println(integerArray[i]);
}
}
}

Output:

Difference Between Static Array and Dynamic Array

The following table describes the key differences between static array and dynamic array.

Static Array	Dynamic Array
Static arrays are allocated memory at compile time.	Dynamic array is located at run-time.
The size of static array is fixed.	The size of dynamic array is fixed.
It is located in stack memory space.	It is located in heap memory space.
int array[10]; //array of size 10	int* array = new int[10];

Next TopicWater Jug Problem in Java

← prev next →