Ragged Arrays Vectors

Ragged Arrays

What is a Ragged Array?

A ragged array (or jagged array) is a 2D array where each row can have different number of columns. Unlike regular 2D arrays, rows have varying lengths.

Regular vs Ragged Array:

// Regular 2D Array (all rows same size)
int[][] regular = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
// All rows have 4 columns

// Ragged Array (different row sizes)
int[][] ragged = {
    {1, 2},
    {3, 4, 5, 6},
    {7, 8, 9}
};
// Row 0: 2 columns
// Row 1: 4 columns
// Row 2: 3 columns

Creating Ragged Arrays

Method 1: Direct Initialization

int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6, 7, 8, 9}
};

Method 2: Step-by-Step

// Create array with 3 rows
int[][] arr = new int[3][];

// Define each row separately
arr[0] = new int[2];        // Row 0: 2 columns
arr[1] = new int[4];        // Row 1: 4 columns
arr[2] = new int[3];        // Row 2: 3 columns

// Initialize values
arr[0][0] = 1;  arr[0][1] = 2;
arr[1][0] = 3;  arr[1][1] = 4;  arr[1][2] = 5;  arr[1][3] = 6;
arr[2][0] = 7;  arr[2][1] = 8;  arr[2][2] = 9;

Accessing Ragged Arrays

int[][] arr = {
    {1, 2},
    {3, 4, 5, 6},
    {7, 8, 9}
};

// Access elements
System.out.println(arr[0][0]);  // 1
System.out.println(arr[1][2]);  // 5
System.out.println(arr[2][1]);  // 8

// Get row lengths
System.out.println(arr[0].length);  // 2
System.out.println(arr[1].length);  // 4
System.out.println(arr[2].length);  // 3

Traversing Ragged Arrays

int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6, 7, 8, 9}
};

// Method 1: for loop
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

// Method 2: for-each
for (int[] row : arr) {
    for (int element : row) {
        System.out.print(element + " ");
    }
    System.out.println();
}

Output:

1 2
3 4 5
6 7 8 9

Example: Student Marks

public class StudentMarks {
    public static void main(String[] args) {
        // Different students have different number of subjects
        int[][] marks = {
            {85, 90},              // Student 1: 2 subjects
            {78, 88, 92},          // Student 2: 3 subjects
            {95, 87, 91, 89}       // Student 3: 4 subjects
        };

        for (int i = 0; i < marks.length; i++) {
            System.out.print("Student " + (i + 1) + ": ");
            int sum = 0;

            for (int j = 0; j < marks[i].length; j++) {
                sum += marks[i][j];
            }

            double average = (double) sum / marks[i].length;
            System.out.printf("Average = %.2f\n", average);
        }
    }
}

Output:

Student 1: Average = 87.50
Student 2: Average = 86.00
Student 3: Average = 90.50

Vectors (ArrayList)

What is a Vector?

Vector is a dynamic array that can grow or shrink in size. In modern Java, ArrayList is preferred over Vector.

ArrayList vs Array:

Creating ArrayList

Import:

import java.util.ArrayList;

Declaration:

ArrayList<Integer> numbers = new ArrayList<>();
ArrayList<String> names = new ArrayList<>();
ArrayList<Double> prices = new ArrayList<>();

Note: Use wrapper classes for primitives:

• int → Integer
• double → Double
• char → Character
• boolean → Boolean

ArrayList Methods

1. add() - Add element:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
System.out.println(fruits);  // [Apple, Banana, Orange]

// Add at specific index
fruits.add(1, "Mango");
System.out.println(fruits);  // [Apple, Mango, Banana, Orange]

2. get() - Get element:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

String first = fruits.get(0);  // "Apple"
String second = fruits.get(1); // "Banana"

3. set() - Update element:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

fruits.set(0, "Mango");  // Replace "Apple" with "Mango"
System.out.println(fruits);  // [Mango, Banana]

4. remove() - Remove element:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

// Remove by index
fruits.remove(1);  // Removes "Banana"

// Remove by value
fruits.remove("Apple");  // Removes "Apple"

System.out.println(fruits);  // [Orange]

5. size() - Get size:

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);

int size = numbers.size();  // 3
System.out.println("Size: " + size);

6. contains() - Check if exists:

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

boolean hasApple = fruits.contains("Apple");   // true
boolean hasMango = fruits.contains("Mango");   // false

7. clear() - Remove all:

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.clear();  // Empty now
System.out.println(numbers.size());  // 0

8. isEmpty() - Check if empty:

ArrayList<String> list = new ArrayList<>();
System.out.println(list.isEmpty());  // true

list.add("Item");
System.out.println(list.isEmpty());  // false

Traversing ArrayList

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

// Method 1: for loop
for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

// Method 2: for-each
for (String fruit : fruits) {
    System.out.println(fruit);
}

Complete Example

import java.util.ArrayList;

public class StudentList {
    public static void main(String[] args) {
        ArrayList<String> students = new ArrayList<>();

        // Add students
        students.add("John");
        students.add("Alice");
        students.add("Bob");
        students.add("Carol");

        System.out.println("Students: " + students);
        System.out.println("Total: " + students.size());

        // Access
        System.out.println("First: " + students.get(0));

        // Update
        students.set(1, "Emma");

        // Remove
        students.remove("Bob");

        // Display all
        System.out.println("\nFinal list:");
        for (String student : students) {
            System.out.println(student);
        }
    }
}

ArrayList vs Vector

Recommendation: Use ArrayList for better performance.

Quick Reference

Ragged Array:

int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6}
};

for (int[] row : arr) {
    for (int element : row) {
        System.out.print(element + " ");
    }
}

ArrayList:

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Item");           // Add
String item = list.get(0);  // Get
list.set(0, "New");         // Update
list.remove(0);             // Remove
int size = list.size();     // Size

Exam Tips

Ragged Arrays:

1. Rows can have different lengths
2. Use arr[i].length for row length
3. Must specify row size individually
4. Useful when data size varies per row

ArrayList:

1. Import java.util.ArrayList
2. Dynamic size (grows/shrinks)
3. Use wrapper classes for primitives
4. size() not length
5. get(index) not arr[index]
6. add(), remove(), set() methods
7. More flexible than arrays

Common Questions:

• What is ragged array?
• Difference between regular and ragged array?
• What is ArrayList?
• Difference between Array and ArrayList?
• ArrayList methods?
• Why use ArrayList over Vector?