Java Notes

One Dimensional Array

Complete guide to one-dimensional arrays in Java covering declaration, initialization, memory layout, traversal techniques, input/output operations, and practical programs with detailed explanations.

What is a One-Dimensional Array?

A one-dimensional array (also called a linear array or 1D array) is the simplest form of an array. It is a single row of elements arranged sequentially in memory, where each element is identified by a single index number starting from 0.

Think of a 1D array as a train with numbered compartments. Each compartment can hold one passenger (value), and you identify each compartment by its number (index). The train has a fixed number of compartments that cannot change after it is built.

Visual Representation:

Example

Array: marks +------+------+------+------+------+ | 85 | 90 | 78 | 92 | 88 | +------+------+------+------+------+ [0] [1] [2] [3] [4]

In this example:

Array name: marks
Size: 5 elements
First element: marks[0] = 85
Last element: marks[4] = 88
Valid indices: 0 to 4 (i.e., 0 to length-1)

Declaration of One-Dimensional Array

Declaration creates a reference variable that will eventually point to an array. No memory is allocated for elements at this point.

Syntax Options

Example

// Recommended Java style dataType[] variableName; // C/C++ style (also valid in Java) dataType variableName[];

Examples of Declaration

java example

int[] marks;           // Array of integers
double[] prices;       // Array of doubles
String[] names;        // Array of Strings
char[] vowels;         // Array of characters
boolean[] attendance;  // Array of booleans
float[] temperatures;  // Array of floats
long[] populations;    // Array of longs

Important: After declaration, the variable has the value null (for instance/class variables) or is uninitialized (for local variables).

java example

public class DeclarationDemo {
    static int[] classLevel; // Initialized to null automatically
    
    public static void main(String[] args) {
        int[] localArr; // NOT initialized — using it causes compile error
        System.out.println(classLevel); // Prints: null
        // System.out.println(localArr); // Compile error!
    }
}

Output

null

Creation (Memory Allocation)

The new keyword allocates memory in the heap for the array elements.

Syntax

Example

variableName = new dataType[size]; // Or combined with declaration: dataType[] variableName = new dataType[size];

Size Rules

Size must be a non-negative integer (0 is valid — creates an empty array)
Size can be a variable, expression, or constant
Size is fixed once created — cannot be changed later

Example

public class ArrayCreation { public static void main(String[] args) { // Size as literal int[] arr1 = new int[5]; // Size as variable int n = 10; int[] arr2 = new int[n]; // Size as expression int[] arr3 = new int[n * 2]; // Zero-size array (valid but empty) int[] arr4 = new int[0]; System.out.println("arr1 length: " + arr1.length); System.out.println("arr2 length: " + arr2.length); System.out.println("arr3 length: " + arr3.length); System.out.println("arr4 length: " + arr4.length); } }

Output

arr1 length: 5
arr2 length: 10
arr3 length: 20
arr4 length: 0

Memory Layout After Creation

Example

int[] scores = new int[4];

Memory Diagram:

+----------+ Address	0x7A20 0x7A24 0x7A28 0x7A2C
Index	[0] [1] [2] [3]
- Class	int[]
- Length	4
- Element size	4 bytes (int)
- Total data	16 bytes

Initialization Techniques

Technique 1: Individual Assignment

Example

public class IndividualAssignment { public static void main(String[] args) { int[] primes = new int[5]; primes[0] = 2; primes[1] = 3; primes[2] = 5; primes[3] = 7; primes[4] = 11; for (int p : primes) { System.out.print(p + " "); } System.out.println(); } }

Output

2 3 5 7 11

Technique 2: Array Literal (Static Initialization)

java example

public class ArrayLiteral {
    public static void main(String[] args) {
        // Declaration + initialization in one line
        int[] fibonacci = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34};
        String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
        char[] grades = {'A', 'B', 'C', 'D', 'F'};
        
        System.out.println("Fibonacci: " + java.util.Arrays.toString(fibonacci));
        System.out.println("Days: " + java.util.Arrays.toString(days));
        System.out.println("Grades: " + java.util.Arrays.toString(grades));
    }
}

Output

Fibonacci: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Days: [Mon, Tue, Wed, Thu, Fri, Sat, Sun]
Grades: [A, B, C, D, F]

Technique 3: Using Loop Initialization

Example

public class LoopInit { public static void main(String[] args) { // Initialize with computed values int[] squares = new int[10]; for (int i = 0; i < squares.length; i++) { squares[i] = (i + 1) * (i + 1); } System.out.println("Squares of 1-10: " + java.util.Arrays.toString(squares)); // Initialize with random values int[] random = new int[5]; for (int i = 0; i < random.length; i++) { random[i] = (int)(Math.random() * 100) + 1; // 1 to 100 } System.out.println("Random: " + java.util.Arrays.toString(random)); } }

Output

Squares of 1-10: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Random: [42, 87, 15, 63, 91]

Technique 4: Using Arrays.fill()

Example

import java.util.Arrays; public class ArraysFillDemo { public static void main(String[] args) { // Fill entire array with same value int[] allFives = new int[8]; Arrays.fill(allFives, 5); System.out.println("All fives: " + Arrays.toString(allFives)); // Fill a range [fromIndex, toIndex) int[] partial = new int[10]; Arrays.fill(partial, 2, 7, 99); // Fill index 2 to 6 with 99 System.out.println("Partial fill: " + Arrays.toString(partial)); } }

Output

All fives: [5, 5, 5, 5, 5, 5, 5, 5]
Partial fill: [0, 0, 99, 99, 99, 99, 99, 0, 0, 0]

Reading Array Input from User

Using Scanner

Example

import java.util.Scanner; import java.util.Arrays; public class ArrayInput { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("Enter array size: "); int n = sc.nextInt(); int[] arr = new int[n]; System.out.println("Enter " + n + " elements:"); for (int i = 0; i < n; i++) { arr[i] = sc.nextInt(); } System.out.println("You entered: " + Arrays.toString(arr)); sc.close(); } }

Output

Enter array size: 5
Enter 5 elements:
10 20 30 40 50
You entered: [10, 20, 30, 40, 50]

Reading String Array

Example

import java.util.Scanner; import java.util.Arrays; public class StringArrayInput { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.print("How many names? "); int n = sc.nextInt(); sc.nextLine(); // Consume the newline String[] names = new String[n]; System.out.println("Enter " + n + " names:"); for (int i = 0; i < n; i++) { names[i] = sc.nextLine(); } System.out.println("Names: " + Arrays.toString(names)); sc.close(); } }

Output

How many names? 3
Enter 3 names:
Alice
Bob
Charlie
Names: [Alice, Bob, Charlie]

Array Traversal Methods

Forward Traversal

Example

public class ForwardTraversal { public static void main(String[] args) { int[] arr = {10, 20, 30, 40, 50}; System.out.println("Forward traversal:"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } }

Output

Forward traversal:
10 20 30 40 50

Reverse Traversal

Example

public class ReverseTraversal { public static void main(String[] args) { int[] arr = {10, 20, 30, 40, 50}; System.out.println("Reverse traversal:"); for (int i = arr.length - 1; i >= 0; i--) { System.out.print(arr[i] + " "); } System.out.println(); } }

Output

Reverse traversal:
50 40 30 20 10

Using Enhanced For Loop

java example

public class EnhancedForLoop {
    public static void main(String[] args) {
        double[] temperatures = {36.5, 37.2, 38.0, 36.8, 37.5};
        
        double sum = 0;
        for (double temp : temperatures) {
            sum += temp;
        }
        
        System.out.printf("Average temperature: %.2f%n", sum / temperatures.length);
    }
}

Output

Average temperature: 37.20

Array Copying

Shallow Copy (Reference Copy)

Example

import java.util.Arrays; public class ShallowCopy { public static void main(String[] args) { int[] original = {1, 2, 3, 4, 5}; int[] copy = original; // Both point to SAME array! copy[0] = 99; // Changes original too! System.out.println("Original: " + Arrays.toString(original)); System.out.println("Copy: " + Arrays.toString(copy)); System.out.println("Same object? " + (original == copy)); } }

Output

Original: [99, 2, 3, 4, 5]
Copy: [99, 2, 3, 4, 5]
Same object? true

Deep Copy Methods

Example

import java.util.Arrays; public class DeepCopy { public static void main(String[] args) { int[] original = {1, 2, 3, 4, 5}; // Method 1: Arrays.copyOf() int[] copy1 = Arrays.copyOf(original, original.length); // Method 2: System.arraycopy() int[] copy2 = new int[original.length]; System.arraycopy(original, 0, copy2, 0, original.length); // Method 3: clone() int[] copy3 = original.clone(); // Method 4: Manual copy int[] copy4 = new int[original.length]; for (int i = 0; i < original.length; i++) { copy4[i] = original[i]; } // Modify original — copies are NOT affected original[0] = 99; System.out.println("Original: " + Arrays.toString(original)); System.out.println("Copy1 (copyOf): " + Arrays.toString(copy1)); System.out.println("Copy2 (arraycopy): " + Arrays.toString(copy2)); System.out.println("Copy3 (clone): " + Arrays.toString(copy3)); System.out.println("Copy4 (manual): " + Arrays.toString(copy4)); } }

Output

Original: [99, 2, 3, 4, 5]
Copy1 (copyOf): [1, 2, 3, 4, 5]
Copy2 (arraycopy): [1, 2, 3, 4, 5]
Copy3 (clone): [1, 2, 3, 4, 5]
Copy4 (manual): [1, 2, 3, 4, 5]

Copying a Range

Example

import java.util.Arrays; public class CopyRange { public static void main(String[] args) { int[] original = {10, 20, 30, 40, 50, 60, 70}; // Copy from index 2 to 5 (exclusive) int[] subArray = Arrays.copyOfRange(original, 2, 5); System.out.println("Sub-array [2, 5): " + Arrays.toString(subArray)); // Copy with larger size (pads with default values) int[] expanded = Arrays.copyOf(original, 10); System.out.println("Expanded: " + Arrays.toString(expanded)); } }

Output

Sub-array [2, 5): [30, 40, 50]
Expanded: [10, 20, 30, 40, 50, 60, 70, 0, 0, 0]

java.util.Arrays Utility Class

The Arrays class provides many useful static methods for working with arrays.

Example

import java.util.Arrays; public class ArraysUtility { public static void main(String[] args) { int[] arr = {34, 12, 56, 78, 23, 45, 89, 1}; // toString - readable representation System.out.println("Original: " + Arrays.toString(arr)); // sort - sorts in ascending order Arrays.sort(arr); System.out.println("Sorted: " + Arrays.toString(arr)); // binarySearch - find element (array MUST be sorted) int index = Arrays.binarySearch(arr, 56); System.out.println("56 found at index: " + index); // equals - compare two arrays int[] arr2 = {1, 12, 23, 34, 45, 56, 78, 89}; System.out.println("Arrays equal? " + Arrays.equals(arr, arr2)); // fill - fill with a value int[] filled = new int[5]; Arrays.fill(filled, 7); System.out.println("Filled: " + Arrays.toString(filled)); } }

Output

Original: [34, 12, 56, 78, 23, 45, 89, 1]
Sorted: [1, 12, 23, 34, 45, 56, 78, 89]
56 found at index: 5
Arrays equal? true
Filled: [7, 7, 7, 7, 7]

Passing 1D Array to Methods

Example

import java.util.Arrays; public class ArrayMethods { // Method to find maximum public static int findMax(int[] arr) { int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } // Method to calculate average public static double average(int[] arr) { int sum = 0; for (int val : arr) { sum += val; } return (double) sum / arr.length; } // Method that modifies array (reverses in place) public static void reverse(int[] arr) { int left = 0, right = arr.length - 1; while (left < right) { int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; left++; right--; } } public static void main(String[] args) { int[] numbers = {45, 23, 78, 12, 56, 89, 34}; System.out.println("Array: " + Arrays.toString(numbers)); System.out.println("Maximum: " + findMax(numbers)); System.out.printf("Average: %.2f%n", average(numbers)); reverse(numbers); System.out.println("Reversed: " + Arrays.toString(numbers)); } }

Output

Array: [45, 23, 78, 12, 56, 89, 34]
Maximum: 89
Average: 48.14
Reversed: [34, 89, 56, 12, 78, 23, 45]

Variable-Length Arguments (Varargs)

Java allows passing a variable number of arguments using varargs, which internally creates an array.

java example

public class VarargsDemo {
    public static int sum(int... numbers) { // Varargs = array
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        System.out.println("Sum(1,2,3): " + sum(1, 2, 3));
        System.out.println("Sum(10,20): " + sum(10, 20));
        System.out.println("Sum(5): " + sum(5));
        System.out.println("Sum(): " + sum());
        
        // Can also pass an array
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println("Sum(array): " + sum(arr));
    }
}

Output

Sum(1,2,3): 6
Sum(10,20): 30
Sum(5): 5
Sum(): 0
Sum(array): 15

Practical Programs

Program 1: Find Second Largest Element

java example

public class SecondLargest {
    public static void main(String[] args) {
        int[] arr = {45, 78, 23, 89, 56, 12, 89, 67};
        
        int first = Integer.MIN_VALUE;
        int second = Integer.MIN_VALUE;
        
        for (int num : arr) {
            if (num > first) {
                second = first;
                first = num;
            } else if (num > second && num != first) {
                second = num;
            }
        }
        
        System.out.println("Array: " + java.util.Arrays.toString(arr));
        System.out.println("Largest: " + first);
        System.out.println("Second Largest: " + second);
    }
}

Output

Array: [45, 78, 23, 89, 56, 12, 89, 67]
Largest: 89
Second Largest: 78

Program 2: Count Even and Odd Numbers

Example

public class EvenOddCount { public static void main(String[] args) { int[] arr = {12, 7, 34, 55, 8, 91, 24, 3, 60, 17}; int even = 0, odd = 0; for (int num : arr) { if (num % 2 == 0) even++; else odd++; } System.out.println("Array: " + java.util.Arrays.toString(arr)); System.out.println("Even count: " + even); System.out.println("Odd count: " + odd); } }

Output

Array: [12, 7, 34, 55, 8, 91, 24, 3, 60, 17]
Even count: 5
Odd count: 5

Program 3: Linear Search

Example

public class LinearSearch { public static int search(int[] arr, int key) { for (int i = 0; i < arr.length; i++) { if (arr[i] == key) { return i; // Found at index i } } return -1; // Not found } public static void main(String[] args) { int[] arr = {23, 45, 12, 78, 56, 34, 90}; int key = 78; int result = search(arr, key); if (result != -1) { System.out.println(key + " found at index " + result); } else { System.out.println(key + " not found"); } } }

Output

78 found at index 3

Common Mistakes

1. Forgetting that Indices Start at 0

Example

int[] arr = {10, 20, 30}; // First element is arr[0], NOT arr[1] // Last element is arr[2], NOT arr[3]

2. ArrayIndexOutOfBoundsException in Loops

Example

int[] arr = new int[5]; // WRONG: for (int i = 0; i <= arr.length; i++) // <= causes exception // RIGHT: for (int i = 0; i < arr.length; i++)

3. Reference Copy vs Value Copy

Example

int[] a = {1, 2, 3}; int[] b = a; // b and a point to SAME array b[0] = 99; // a[0] is also 99 now! // Use Arrays.copyOf(a, a.length) for independent copy

4. Using Uninitialized Local Array

Example

int[] arr; // System.out.println(arr.length); // Compile error! // Must assign before use: arr = new int[5];

5. Trying to Print Array with println()

Example

int[] arr = {1, 2, 3}; // System.out.println(arr); // Prints [I@hashcode — not useful System.out.println(java.util.Arrays.toString(arr)); // Correct: [1, 2, 3]

Best Practices

Use arr.length in loop conditions — never hardcode array size
Prefer for-each when only reading elements (cleaner, no index errors)
Validate array bounds before accessing computed indices
Use Arrays.toString() for debugging and printing
Use Arrays.sort() instead of writing your own sort for production code
Consider ArrayList if size is unknown at compile time
Use Arrays.copyOf() for safe copies instead of manual loops
Initialize arrays in constructors or at declaration for class fields
Avoid magic numbers — use named constants for array sizes
Check for null before operating on arrays received as parameters

Interview Questions

Q1: What is a one-dimensional array? A 1D array is a linear data structure storing elements of the same type in contiguous memory, accessed by a single integer index starting from 0.

Q2: What happens if we access index -1 or index >= length? Java throws ArrayIndexOutOfBoundsException at runtime.

Q3: How do you resize an array in Java? You cannot resize. Create a new array with the desired size and copy elements using Arrays.copyOf() or System.arraycopy().

Q4: What is the difference between int[] a = b and int[] a = b.clone()? a = b makes both variables point to the same array (reference copy). a = b.clone() creates a new array with the same values (deep copy for primitives).

Q5: Can array size be 0? Yes. new int[0] creates a valid array with length 0. Useful as return value when no results exist.

Q6: What is the maximum size of an array in Java? Theoretically Integer.MAX_VALUE (2^31 - 1 ≈ 2.1 billion), but practically limited by available heap memory.

Q7: How does for-each loop work with arrays? The compiler converts for(int x : arr) to a regular for loop with index. You cannot modify the array or know the current index with for-each.

Q8: What is System.arraycopy() and how is it different from Arrays.copyOf()? System.arraycopy(src, srcPos, dest, destPos, length) copies elements between existing arrays. Arrays.copyOf(src, newLength) creates a new array and copies elements. Both use native memory operations and are faster than manual loops.

Q9: What are varargs and how do they relate to arrays? Varargs (int... args) allow passing variable number of arguments to a method. Internally, Java creates an array from the arguments.

Q10: Why is array access O(1)? Because elements are in contiguous memory. The address of element i is calculated as: baseAddress + i * elementSize. This formula gives instant access regardless of array size.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for One Dimensional Array.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, fundamentals, arrays, one

Continue learning this concept

FundamentalsMulti Dimensional ArrayComplete guide to multi-dimensional arrays in Java covering 2D arrays, 3D arrays, matrix operations, memory layout, row-major storage, traversal techniques, and practical applications.FundamentalsArray IntroductionComplete introduction to arrays in Java covering definition, memory layout, types of arrays, declaration, initialization, accessing elements, and real-world use cases with detailed examples.FundamentalsArray OperationsComplete guide to array operations in Java covering searching, sorting, insertion, deletion, merging, rotation, reversing, and all java.util.Arrays class methods with detailed examples.FundamentalsArray Programs — Fundamentals20+ complete Java array programs with solutions, detailed explanations, step-by-step logic, input/output examples covering all common array programming problems.FundamentalsJagged Array in JavaComplete guide to jagged arrays in Java covering definition, creation, memory layout, initialization techniques, real-world applications, and comparison with rectangular arrays.FundamentalsArray Interview QuestionsComprehensive collection of Java array interview questions and answers covering conceptual, coding, and tricky questions asked in TCS, Infosys, Wipro, Amazon, and Google interviews.

PreviousMulti Dimensional Array Nextbreak and continue in Java

Java Notes

One Dimensional Array

Complete guide to one-dimensional arrays in Java covering declaration, initialization, memory layout, traversal techniques, input/output operations, and practical programs with detailed explanations.

What is a One-Dimensional Array?

Visual Representation:

Example

Array: marks +------+------+------+------+------+ | 85 | 90 | 78 | 92 | 88 | +------+------+------+------+------+ [0] [1] [2] [3] [4]

In this example:

Array name: marks
Size: 5 elements
First element: marks[0] = 85
Last element: marks[4] = 88
Valid indices: 0 to 4 (i.e., 0 to length-1)

Declaration of One-Dimensional Array

Declaration creates a reference variable that will eventually point to an array. No memory is allocated for elements at this point.

Syntax Options

Example

// Recommended Java style dataType[] variableName; // C/C++ style (also valid in Java) dataType variableName[];

Examples of Declaration

java example

int[] marks;           // Array of integers
double[] prices;       // Array of doubles
String[] names;        // Array of Strings
char[] vowels;         // Array of characters
boolean[] attendance;  // Array of booleans
float[] temperatures;  // Array of floats
long[] populations;    // Array of longs

Important: After declaration, the variable has the value null (for instance/class variables) or is uninitialized (for local variables).

java example

public class DeclarationDemo {
    static int[] classLevel; // Initialized to null automatically
    
    public static void main(String[] args) {
        int[] localArr; // NOT initialized — using it causes compile error
        System.out.println(classLevel); // Prints: null
        // System.out.println(localArr); // Compile error!
    }
}

Output

null

Creation (Memory Allocation)

The new keyword allocates memory in the heap for the array elements.

Syntax

Example

variableName = new dataType[size]; // Or combined with declaration: dataType[] variableName = new dataType[size];

Size Rules

Size must be a non-negative integer (0 is valid — creates an empty array)
Size can be a variable, expression, or constant
Size is fixed once created — cannot be changed later

Example

Output

arr1 length: 5
arr2 length: 10
arr3 length: 20
arr4 length: 0

Memory Layout After Creation

Example

int[] scores = new int[4];

Memory Diagram:

+----------+ Address	0x7A20 0x7A24 0x7A28 0x7A2C
Index	[0] [1] [2] [3]
- Class	int[]
- Length	4
- Element size	4 bytes (int)
- Total data	16 bytes

Initialization Techniques

Technique 1: Individual Assignment

Example

Output

2 3 5 7 11

Technique 2: Array Literal (Static Initialization)

java example

public class ArrayLiteral {
    public static void main(String[] args) {
        // Declaration + initialization in one line
        int[] fibonacci = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34};
        String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
        char[] grades = {'A', 'B', 'C', 'D', 'F'};
        
        System.out.println("Fibonacci: " + java.util.Arrays.toString(fibonacci));
        System.out.println("Days: " + java.util.Arrays.toString(days));
        System.out.println("Grades: " + java.util.Arrays.toString(grades));
    }
}

Output

Fibonacci: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Days: [Mon, Tue, Wed, Thu, Fri, Sat, Sun]
Grades: [A, B, C, D, F]

Technique 3: Using Loop Initialization

Example

Output

Squares of 1-10: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Random: [42, 87, 15, 63, 91]

Technique 4: Using Arrays.fill()

Example

Output

All fives: [5, 5, 5, 5, 5, 5, 5, 5]
Partial fill: [0, 0, 99, 99, 99, 99, 99, 0, 0, 0]

Reading Array Input from User

Using Scanner

Example

Output

Enter array size: 5
Enter 5 elements:
10 20 30 40 50
You entered: [10, 20, 30, 40, 50]

Reading String Array

Example

Output

How many names? 3
Enter 3 names:
Alice
Bob
Charlie
Names: [Alice, Bob, Charlie]

Array Traversal Methods

Forward Traversal

Example

Output

Forward traversal:
10 20 30 40 50

Reverse Traversal

Example

Output

Reverse traversal:
50 40 30 20 10

Using Enhanced For Loop

java example

public class EnhancedForLoop {
    public static void main(String[] args) {
        double[] temperatures = {36.5, 37.2, 38.0, 36.8, 37.5};
        
        double sum = 0;
        for (double temp : temperatures) {
            sum += temp;
        }
        
        System.out.printf("Average temperature: %.2f%n", sum / temperatures.length);
    }
}

Output

Average temperature: 37.20

Array Copying

Shallow Copy (Reference Copy)

Example

Output

Original: [99, 2, 3, 4, 5]
Copy: [99, 2, 3, 4, 5]
Same object? true

Deep Copy Methods

Example

Output

Original: [99, 2, 3, 4, 5]
Copy1 (copyOf): [1, 2, 3, 4, 5]
Copy2 (arraycopy): [1, 2, 3, 4, 5]
Copy3 (clone): [1, 2, 3, 4, 5]
Copy4 (manual): [1, 2, 3, 4, 5]

Copying a Range

Example

Output

Sub-array [2, 5): [30, 40, 50]
Expanded: [10, 20, 30, 40, 50, 60, 70, 0, 0, 0]

java.util.Arrays Utility Class

The Arrays class provides many useful static methods for working with arrays.

Example

Output

Original: [34, 12, 56, 78, 23, 45, 89, 1]
Sorted: [1, 12, 23, 34, 45, 56, 78, 89]
56 found at index: 5
Arrays equal? true
Filled: [7, 7, 7, 7, 7]

Passing 1D Array to Methods

Example

Output

Array: [45, 23, 78, 12, 56, 89, 34]
Maximum: 89
Average: 48.14
Reversed: [34, 89, 56, 12, 78, 23, 45]

Variable-Length Arguments (Varargs)

Java allows passing a variable number of arguments using varargs, which internally creates an array.

java example

public class VarargsDemo {
    public static int sum(int... numbers) { // Varargs = array
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        System.out.println("Sum(1,2,3): " + sum(1, 2, 3));
        System.out.println("Sum(10,20): " + sum(10, 20));
        System.out.println("Sum(5): " + sum(5));
        System.out.println("Sum(): " + sum());
        
        // Can also pass an array
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println("Sum(array): " + sum(arr));
    }
}

Output

Sum(1,2,3): 6
Sum(10,20): 30
Sum(5): 5
Sum(): 0
Sum(array): 15

Practical Programs

Program 1: Find Second Largest Element

java example

public class SecondLargest {
    public static void main(String[] args) {
        int[] arr = {45, 78, 23, 89, 56, 12, 89, 67};
        
        int first = Integer.MIN_VALUE;
        int second = Integer.MIN_VALUE;
        
        for (int num : arr) {
            if (num > first) {
                second = first;
                first = num;
            } else if (num > second && num != first) {
                second = num;
            }
        }
        
        System.out.println("Array: " + java.util.Arrays.toString(arr));
        System.out.println("Largest: " + first);
        System.out.println("Second Largest: " + second);
    }
}

Output

Array: [45, 78, 23, 89, 56, 12, 89, 67]
Largest: 89
Second Largest: 78

Program 2: Count Even and Odd Numbers

Example

Output

Array: [12, 7, 34, 55, 8, 91, 24, 3, 60, 17]
Even count: 5
Odd count: 5

Program 3: Linear Search

Example

Output

78 found at index 3

Common Mistakes

1. Forgetting that Indices Start at 0

Example

int[] arr = {10, 20, 30}; // First element is arr[0], NOT arr[1] // Last element is arr[2], NOT arr[3]

2. ArrayIndexOutOfBoundsException in Loops

Example

int[] arr = new int[5]; // WRONG: for (int i = 0; i <= arr.length; i++) // <= causes exception // RIGHT: for (int i = 0; i < arr.length; i++)

3. Reference Copy vs Value Copy

Example

int[] a = {1, 2, 3}; int[] b = a; // b and a point to SAME array b[0] = 99; // a[0] is also 99 now! // Use Arrays.copyOf(a, a.length) for independent copy

4. Using Uninitialized Local Array

Example

int[] arr; // System.out.println(arr.length); // Compile error! // Must assign before use: arr = new int[5];

5. Trying to Print Array with println()

Example

int[] arr = {1, 2, 3}; // System.out.println(arr); // Prints [I@hashcode — not useful System.out.println(java.util.Arrays.toString(arr)); // Correct: [1, 2, 3]

Best Practices

Use arr.length in loop conditions — never hardcode array size
Prefer for-each when only reading elements (cleaner, no index errors)
Validate array bounds before accessing computed indices
Use Arrays.toString() for debugging and printing
Use Arrays.sort() instead of writing your own sort for production code
Consider ArrayList if size is unknown at compile time
Use Arrays.copyOf() for safe copies instead of manual loops
Initialize arrays in constructors or at declaration for class fields
Avoid magic numbers — use named constants for array sizes
Check for null before operating on arrays received as parameters

Interview Questions

Q1: What is a one-dimensional array? A 1D array is a linear data structure storing elements of the same type in contiguous memory, accessed by a single integer index starting from 0.

Q2: What happens if we access index -1 or index >= length? Java throws ArrayIndexOutOfBoundsException at runtime.

Q3: How do you resize an array in Java? You cannot resize. Create a new array with the desired size and copy elements using Arrays.copyOf() or System.arraycopy().

Q5: Can array size be 0? Yes. new int[0] creates a valid array with length 0. Useful as return value when no results exist.

Q6: What is the maximum size of an array in Java? Theoretically Integer.MAX_VALUE (2^31 - 1 ≈ 2.1 billion), but practically limited by available heap memory.

Q7: How does for-each loop work with arrays? The compiler converts for(int x : arr) to a regular for loop with index. You cannot modify the array or know the current index with for-each.

Q9: What are varargs and how do they relate to arrays? Varargs (int... args) allow passing variable number of arguments to a method. Internally, Java creates an array from the arguments.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for One Dimensional Array.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, fundamentals, arrays, one

Continue learning this concept

PreviousMulti Dimensional Array Nextbreak and continue in Java