4.1 Array Initialization

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created and cannot be changed.

Key Characteristics

• Fixed size: Once created, the size cannot be modified
• Homogeneous elements: All elements must be of the same data type
• Zero-based indexing: First element is at index 0
• Contiguous memory allocation: Elements are stored in consecutive memory locations

Array initialization refers to the process of creating an array and assigning initial values to its elements. This can be done in several ways depending on when you know the values.

Declaration vs Initialization

Array Declaration

// Syntax: dataType[] arrayName;
int[] numbers;          // Declaration only
String[] names;         // No memory allocated yet
double[] prices;        // Array reference is null

Array Initialization

// Memory allocation and value assignment
int[] numbers = new int[5];         // Initialize with default values
String[] names = {"Alice", "Bob"};  // Initialize with specific values

Methods of Array Initialization

1. Default Initialization with new Keyword

// Syntax: dataType[] arrayName = new dataType[size];
int[] numbers = new int[5];          // Array of 5 integers
boolean[] flags = new boolean[3];    // Array of 3 booleans
String[] words = new String[4];      // Array of 4 Strings

Memory Allocation:

numbers → [0][0][0][0][0]  (all zeros)
flags  → [false][false][false]
words  → [null][null][null][null]

2. Explicit Initialization with Values

// Syntax: dataType[] arrayName = {value1, value2, ..., valueN};
int[] primes = {2, 3, 5, 7, 11};
String[] colors = {"Red", "Green", "Blue"};
char[] vowels = {'a', 'e', 'i', 'o', 'u'};
boolean[] answers = {true, false, true};

3. Combined Declaration and Initialization

// Declaration and initialization in separate steps
int[] scores;
scores = new int[]{85, 92, 78, 90};  // Note: size is inferred

// This is useful when returning arrays from methods
public int[] getScores() {
    return new int[]{85, 92, 78, 90};
}

4. Anonymous Array Initialization

// Creating an array without storing reference (for immediate use)
System.out.println(new int[]{1, 2, 3}.length);  // Output: 3

// Useful for method parameters
printArray(new String[]{"Java", "Python", "C++"});

5. Multi-step Initialization

// Step 1: Declaration
int[] values;

// Step 2: Memory allocation
values = new int[3];

// Step 3: Individual element assignment
values[0] = 10;
values[1] = 20;
values[2] = 30;

Default Values

When arrays are initialized using the new keyword without explicit values, Java assigns default values based on the data type:

Data Type	Default Value
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	'\u0000' (null character)
boolean	false
Object	null

Examples of Default Values

// Numeric types default to 0
int[] numbers = new int[3];
System.out.println(numbers[0]);  // Output: 0

// boolean defaults to false
boolean[] flags = new boolean[2];
System.out.println(flags[0]);    // Output: false

// Objects default to null
String[] names = new String[3];
System.out.println(names[0]);    // Output: null

// char defaults to null character
char[] letters = new char[2];
System.out.println((int)letters[0]);  // Output: 0

Complete Examples

Example 1: Student Grades

public class GradeSystem {
    public static void main(String[] args) {
        // Initialize array with specific grades
        int[] grades = {85, 92, 78, 90, 88};
        
        // Calculate average
        int sum = 0;
        for (int grade : grades) {
            sum += grade;
        }
        double average = (double) sum / grades.length;
        System.out.println("Average grade: " + average);
    }
}

Example 2: Temperature Tracking

public class TemperatureTracker {
    public static void main(String[] args) {
        // Initialize with default values
        double[] temperatures = new double[7];
        
        // Assign values later
        temperatures[0] = 72.5;
        temperatures[1] = 68.3;
        temperatures[2] = 75.1;
        // ... and so on
        
        System.out.println("Monday temperature: " + temperatures[0]);
    }
}

Example 3: String Array Manipulation

public class StringArrayExample {
    public static void main(String[] args) {
        // Initialize string array
        String[] programmingLanguages = {"Java", "Python", "JavaScript", "C++", "Ruby"};
        
        // Print all languages
        for (String language : programmingLanguages) {
            System.out.println(language);
        }
        
        // Find array length
        System.out.println("Number of languages: " + programmingLanguages.length);
    }
}

Common Mistakes and Best Practices

Common Mistakes

1. Accessing uninitialized array

   int[] numbers;  // Only declared, not initialized
   System.out.println(numbers[0]);  // Compilation error

2. Wrong initialization syntax

   int[] numbers = new int[3]{1, 2, 3};  // Error: Cannot specify size and values
   int[] numbers = new int[]{1, 2, 3};   // Correct

3. Out of bounds access

   int[] arr = new int[3];
   System.out.println(arr[5]);  // ArrayIndexOutOfBoundsException

Best Practices

1. Use meaningful array names

   // Good
   int[] studentAges = new int[50];
   String[] employeeNames = new String[100];
   
   // Avoid
   int[] a = new int[50];
   String[] s = new String[100];

2. Initialize with known values when possible

   // Better - more readable
   String[] daysOfWeek = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
   
   // Less readable
   String[] days = new String[7];
   days[0] = "Mon";
   days[1] = "Tue";
   // ...

3. Use constants for array sizes

   final int CLASS_SIZE = 30;
   int[] studentScores = new int[CLASS_SIZE];

Summary

• Arrays are fixed-size containers for homogeneous elements
• Initialization can be done with default values or explicit values
• Default values depend on the data type (0, false, null, etc.)
• Multiple initialization methods provide flexibility
• Always ensure arrays are properly initialized before use

In the next section, we'll learn how to access and manipulate array elements using indices and loops.