Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to jagged arrays in Java covering definition, creation, memory layout, initialization techniques, real-world applications, and comparison with rectangular arrays.
What is a Jagged Array?
A jagged array (also called a ragged array or irregular array) is a multi-dimensional array where each row can have a different number of columns. Unlike a rectangular 2D array where every row has the same length, a jagged array allows rows to be of varying sizes.
Think of it like a staircase — each step (row) can have a different width (number of columns).
Visual Comparison
Rectangular Array (3×4):
| | 1 | 2 | 3 | 4 | Row 0 | 4 elements |
| | 5 | 6 | 7 | 8 | Row 1 | 4 elements |
| | 9 | 10| 11| 12| Row 2 | 4 elements |
Jagged Array:
| | 1 | 2 | Row 0 | 2 elements |
| | 3 | 4 | 5 | 6 | 7 | Row 1 | 5 elements |
| | 8 | 9 | 10| Row 2 | 3 elements |
| | 11| Row 3 | 1 element |
Why Use Jagged Arrays?
Jagged arrays are useful when:
- Rows have naturally different sizes — e.g., students in different classes have different numbers of subjects
- Memory optimization — avoid wasting memory on unused cells in a rectangular array
- Representing triangular data — Pascal's triangle, lower/upper triangular matrices
- Irregular data structures — organization hierarchy where each level has different breadth
- Variable-length records — each student might have taken a different number of exams
Memory Savings Example
If you need to store data for 100 rows where:
- 50 rows need 2 columns
- 30 rows need 5 columns
- 20 rows need 10 columns
Rectangular array: 100 × 10 = 1000 cells (many wasted) Jagged array: (50×2) + (30×5) + (20×10) = 100 + 150 + 200 = 450 cells (no waste)
Creating a Jagged Array
Step 1: Declare and Create Outer Array
Example
int[][] jagged = new int[4][]; // 4 rows, columns not specified yet
At this point, jagged is an array of 4 null references — no inner arrays exist yet.
Step 2: Create Inner Arrays with Different Sizes
Example
jagged[0] = new int[2]; // Row 0 has 2 columns
jagged[1] = new int[5]; // Row 1 has 5 columns
jagged[2] = new int[3]; // Row 2 has 3 columns
jagged[3] = new int[1]; // Row 3 has 1 column
Complete Example
Example
import java.util.Arrays;
public class JaggedArrayCreation {
public static void main(String[] args) {
// Step 1: Create outer array
int[][] jagged = new int[4][];
// Step 2: Create inner arrays of different sizes
jagged[0] = new int[2];
jagged[1] = new int[5];
jagged[2] = new int[3];
jagged[3] = new int[1];
// Step 3: Assign values
jagged[0][0] = 1; jagged[0][1] = 2;
jagged[1][0] = 3; jagged[1][1] = 4; jagged[1][2] = 5;
jagged[1][3] = 6; jagged[1][4] = 7;
jagged[2][0] = 8; jagged[2][1] = 9; jagged[2][2] = 10;
jagged[3][0] = 11;
// Print
for (int i = 0; i < jagged.length; i++) {
System.out.println("Row " + i + " (length " + jagged[i].length + "): "
+ Arrays.toString(jagged[i]));
}
}
}
Output
Row 0 (length 2): [1, 2] Row 1 (length 5): [3, 4, 5, 6, 7] Row 2 (length 3): [8, 9, 10] Row 3 (length 1): [11]
Memory Layout
Example
int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[4];
jagged[2] = new int[3];
Memory Diagram:
Example
STACK HEAP
+----------+
| jagged |———> +----------+----------+----------+
| (ref) | | jagged[0]| jagged[1]| jagged[2]| <- Outer array (3 refs)
+----------+ +-----+----+-----+----+-----+----+
| | |
v v v
+---+---+ +---+---+---+---+ +---+---+---+
| 0 | 0 | | 0 | 0 | 0 | 0 | | 0 | 0 | 0 |
+---+---+ +---+---+---+---+ +---+---+---+
2 elements 4 elements 3 elements
Key Points:
- The outer array contains references (not actual data)
- Each reference points to a separate int[] object in heap
- Inner arrays can be at any location in heap (not necessarily adjacent)
- Total memory: outer array (3 refs × 8 bytes) + inner arrays (2+4+3 ints × 4 bytes) = 24 + 36 = 60 bytes (plus object headers)
Initialization Methods
Method 1: Array Literal
java example
public class JaggedLiteral {
public static void main(String[] args) {
int[][] jagged = {
{1, 2},
{3, 4, 5, 6, 7},
{8, 9, 10},
{11}
};
for (int[] row : jagged) {
System.out.println(java.util.Arrays.toString(row));
}
}
}Output
[1, 2] [3, 4, 5, 6, 7] [8, 9, 10] [11]
Method 2: Using Loop with Varying Sizes
Example
public class JaggedLoopInit {
public static void main(String[] args) {
// Create triangular jagged array (row i has i+1 elements)
int[][] triangle = new int[5][];
int value = 1;
for (int i = 0; i < triangle.length; i++) {
triangle[i] = new int[i + 1]; // Row 0 has 1 elem, Row 1 has 2, etc.
for (int j = 0; j <= i; j++) {
triangle[i][j] = value++;
}
}
// Print as triangle
for (int[] row : triangle) {
for (int elem : row) {
System.out.printf("%4d", elem);
}
System.out.println();
}
}
}
Output
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Method 3: User Input
Example
import java.util.Scanner;
import java.util.Arrays;
public class JaggedInput {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter number of rows: ");
int rows = sc.nextInt();
int[][] jagged = new int[rows][];
for (int i = 0; i < rows; i++) {
System.out.print("Enter number of columns for row " + i + ": ");
int cols = sc.nextInt();
jagged[i] = new int[cols];
System.out.print("Enter " + cols + " elements: ");
for (int j = 0; j < cols; j++) {
jagged[i][j] = sc.nextInt();
}
}
System.out.println("\nJagged Array:");
for (int i = 0; i < jagged.length; i++) {
System.out.println("Row " + i + ": " + Arrays.toString(jagged[i]));
}
sc.close();
}
}
Output
Enter number of rows: 3 Enter number of columns for row 0: 2 Enter 2 elements: 10 20 Enter number of columns for row 1: 4 Enter 4 elements: 30 40 50 60 Enter number of columns for row 2: 3 Enter 3 elements: 70 80 90 Jagged Array: Row 0: [10, 20] Row 1: [30, 40, 50, 60] Row 2: [70, 80, 90]
Traversing a Jagged Array
Important: Use row-specific length
Example
public class JaggedTraversal {
public static void main(String[] args) {
int[][] jagged = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}, {10}};
// Method 1: Traditional for loop
System.out.println("Using for loop:");
for (int i = 0; i < jagged.length; i++) {
for (int j = 0; j < jagged[i].length; j++) { // jagged[i].length — NOT jagged[0].length!
System.out.print(jagged[i][j] + " ");
}
System.out.println();
}
// Method 2: Enhanced for loop
System.out.println("\nUsing for-each:");
for (int[] row : jagged) {
for (int elem : row) {
System.out.print(elem + " ");
}
System.out.println();
}
// Total element count
int total = 0;
for (int[] row : jagged) {
total += row.length;
}
System.out.println("\nTotal elements: " + total);
}
}
Output
Using for loop: 1 2 3 4 5 6 7 8 9 10 Using for-each: 1 2 3 4 5 6 7 8 9 10 Total elements: 10
Practical Applications
Application 1: Pascal's Triangle
Example
public class PascalTriangle {
public static void main(String[] args) {
int n = 6; // Number of rows
int[][] pascal = new int[n][];
for (int i = 0; i < n; i++) {
pascal[i] = new int[i + 1];
pascal[i][0] = 1; // First element is always 1
pascal[i][i] = 1; // Last element is always 1
for (int j = 1; j < i; j++) {
pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j];
}
}
// Print with formatting
for (int i = 0; i < n; i++) {
// Leading spaces for pyramid shape
for (int s = 0; s < n - i - 1; s++) {
System.out.print(" ");
}
for (int j = 0; j <= i; j++) {
System.out.printf("%6d", pascal[i][j]);
}
System.out.println();
}
}
}
Output
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1Application 2: Student Marks (Different Subjects)
Example
import java.util.Arrays;
public class StudentMarks {
public static void main(String[] args) {
String[] students = {"Alice", "Bob", "Charlie"};
String[][] subjects = {
{"Math", "Science", "English"}, // Alice: 3 subjects
{"Math", "Science", "English", "Art"}, // Bob: 4 subjects
{"Math", "English"} // Charlie: 2 subjects
};
int[][] marks = {
{85, 92, 78}, // Alice's marks
{90, 88, 76, 95}, // Bob's marks
{72, 80} // Charlie's marks
};
for (int i = 0; i < students.length; i++) {
System.out.println(students[i] + " (" + marks[i].length + " subjects):");
double total = 0;
for (int j = 0; j < marks[i].length; j++) {
System.out.println(" " + subjects[i][j] + ": " + marks[i][j]);
total += marks[i][j];
}
System.out.printf(" Average: %.2f%n%n", total / marks[i].length);
}
}
}
Output
Alice (3 subjects): Math: 85 Science: 92 English: 78 Average: 85.00 Bob (4 subjects): Math: 90 Science: 88 English: 76 Art: 95 Average: 87.25 Charlie (2 subjects): Math: 72 English: 80 Average: 76.00
Application 3: Lower Triangular Matrix
Example
public class LowerTriangular {
public static void main(String[] args) {
int n = 4;
int[][] lower = new int[n][];
// Row i has (i+1) elements in lower triangular
int value = 1;
for (int i = 0; i < n; i++) {
lower[i] = new int[i + 1];
for (int j = 0; j <= i; j++) {
lower[i][j] = value++;
}
}
// Print as matrix (with zeros for missing elements)
System.out.println("Lower Triangular Matrix:");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j <= i) {
System.out.printf("%4d", lower[i][j]);
} else {
System.out.printf("%4d", 0);
}
}
System.out.println();
}
System.out.println("\nActual jagged storage:");
for (int[] row : lower) {
System.out.println(Arrays.toString(row));
}
}
}
Output
Lower Triangular Matrix: 1 0 0 0 2 3 0 0 4 5 6 0 7 8 9 10 Actual jagged storage: [1] [2, 3] [4, 5, 6] [7, 8, 9, 10]
Finding Maximum in Jagged Array
Example
public class JaggedMax {
public static void main(String[] args) {
int[][] jagged = {{45, 23}, {78, 12, 90, 34}, {56, 67, 89}};
int max = Integer.MIN_VALUE;
int maxRow = 0, maxCol = 0;
for (int i = 0; i < jagged.length; i++) {
for (int j = 0; j < jagged[i].length; j++) {
if (jagged[i][j] > max) {
max = jagged[i][j];
maxRow = i;
maxCol = j;
}
}
}
System.out.println("Maximum value: " + max);
System.out.println("Found at position: [" + maxRow + "][" + maxCol + "]");
}
}
Output
Maximum value: 90 Found at position: [1][2]
Jagged Array vs Rectangular Array
| Feature | Rectangular Array | Jagged Array |
|---|---|---|
| Declaration | new int[3][4] | new int[3][] + individual rows |
| Row lengths | All rows same length | Rows can differ |
| Memory | May waste memory | Memory efficient |
| Access speed | Slightly faster (predictable) | Same O(1) per element |
| Use case | Matrices, grids | Irregular data |
| Creation | Single statement | Multiple statements |
| null rows possible | No | Yes (until initialized) |
Common Mistakes
1. Accessing Uninitialized Row
Example
int[][] jagged = new int[3][];
// jagged[0][0] = 5; // NullPointerException! Row 0 is null!
jagged[0] = new int[3]; // Initialize first!
jagged[0][0] = 5; // Now it works
2. Assuming All Rows Have Same Length
Example
int[][] jagged = {{1,2}, {3,4,5}, {6}};
// WRONG: for(int j = 0; j < jagged[0].length; j++)
// This would fail for row 2 which has only 1 element!
// RIGHT: for(int j = 0; j < jagged[i].length; j++)
3. Using deepToString vs toString
java example
int[][] jagged = {{1,2}, {3,4,5}};
// System.out.println(java.util.Arrays.toString(jagged)); // Shows references!
System.out.println(java.util.Arrays.deepToString(jagged)); // Shows values!4. Forgetting to Check for Null Rows
Example
int[][] jagged = new int[3][];
jagged[0] = new int[]{1, 2};
// jagged[1] is still null!
for (int i = 0; i < jagged.length; i++) {
if (jagged[i] != null) { // Always check!
for (int j = 0; j < jagged[i].length; j++) {
System.out.print(jagged[i][j] + " ");
}
}
}
5. Specifying Second Dimension in Declaration
Example
// int[][] jagged = new int[3][4]; // This creates rectangular, NOT jagged!
int[][] jagged = new int[3][]; // Leave second dimension empty for jagged
Best Practices
- Always check for null rows before accessing elements
- Use
jagged[i].lengthfor the inner loop bound (never hardcode or use row 0's length) - Use array literals when data is known at compile time
- Document row size logic — explain why rows have different sizes
- Consider ArrayList<int[]> if number of rows is also dynamic
- Initialize all rows immediately after creating the outer array
- Use for-each when you don't need the index for cleaner code
- Use
Arrays.deepToString()for debugging jagged arrays - Prefer rectangular arrays unless you genuinely have variable row lengths
- Keep track of total elements if needed for algorithms
Interview Questions
Q1: What is a jagged array? A jagged array is a multi-dimensional array where each row can have a different number of columns. It's implemented as an array of references to arrays of varying lengths.
Q2: How is a jagged array different from a rectangular 2D array? In a rectangular array (new int[3][4]), all rows have the same number of columns. In a jagged array (new int[3][]), each row is independently sized.
Q3: How do you get the length of a specific row? Use jagged[rowIndex].length. Each row is an independent array with its own length property.
Q4: What happens if you access a row that hasn't been initialized? You get a NullPointerException because uninitialized rows are null.
Q5: Can you create a jagged array with array literal syntax? Yes: int[][] j = {{1,2}, {3,4,5}, {6}}; — the compiler infers different row sizes.
Q6: What is the memory advantage of jagged arrays? They avoid allocating memory for unused cells. If different rows need different sizes, a rectangular array wastes space on padding.
Q7: How do you find the total number of elements in a jagged array? Sum up jagged[i].length for all rows: for(int[] row : jagged) total += row.length;
Q8: Can a jagged array have null rows? Yes. After new int[3][], all three rows are null until individually initialized.
Q9: What are practical use cases for jagged arrays? Pascal's triangle, triangular matrices, student-subject mapping (varying subjects per student), organizational hierarchies, and sparse data storage.
Q10: How do you deep-copy a jagged array? Loop through each row and clone or copy individually: for(int i=0; i<src.length; i++) dest[i] = src[i].clone();
Q11: Is int[][] a jagged or rectangular array in Java? In Java, ALL 2D arrays are technically jagged (arrays of references). new int[3][4] just happens to initialize all rows with the same length, but you could reassign any row to a different size.
Q12: How do you sort each row of a jagged array independently? Use Arrays.sort(jagged[i]) in a loop for each row.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Jagged Array in Java.
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, jagged
Related Java Master Course Topics
Continue learning this concept
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.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.FundamentalsOne Dimensional ArrayComplete guide to one-dimensional arrays in Java covering declaration, initialization, memory layout, traversal techniques, input/output operations, and practical programs with detailed explanations.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.