Data Structures Quiz for AP Computer Science A (Java)

📚 Quick Study Guide: AP CSA Data Structures (Java)

• 📏 Arrays:
  • ✅ Fixed-size, contiguous collection of elements of the same data type (primitives or objects).
  • ✍️ Declaration: `dataType[] arrayName = new dataType[size];` Example: `int[] numbers = new int[5];`
  • 🔍 Access elements using an index: `arrayName[index]`. Indices range from 0 to `length - 1`.
  • 🔢 Length is accessed via `.length` (e.g., `numbers.length`).
• 📈 ArrayLists:
  • ✨ Dynamic-size, resizable array-like structure that stores objects (cannot store primitives directly).
  • 📝 Declaration: `ArrayList listName = new ArrayList();` Example: `ArrayList names = new ArrayList();`
  • ⚙️ Key Methods:
    • ➕ `add(element)`: Appends an element to the end.
    • 📍 `add(index, element)`: Inserts an element at a specific index.
    • ➡️ `get(index)`: Returns the element at the specified index.
    • 🔄 `set(index, element)`: Replaces the element at the specified index.
    • ✂️ `remove(index)`: Removes the element at the specified index and shifts subsequent elements.
    • 📊 `size()`: Returns the number of elements in the list.
• 🖼️ 2D Arrays (Matrices):
  • 🌐 An array of arrays, representing rows and columns.
  • 📋 Declaration: `dataType[][] matrixName = new dataType[rows][cols];` Example: `int[][] grid = new int[3][4];`
  • 🎯 Access elements using two indices: `matrixName[rowIndex][colIndex]`.
  • 📏 Row length: `matrixName.length`. Column length of a specific row: `matrixName[rowIndex].length`.
• ↔️ Key Differences:
  • 🔒 Arrays have a fixed size; 🔓 ArrayLists are dynamic.
  • 📦 Arrays can store primitives and objects; ♻️ ArrayLists only store objects (use wrapper classes for primitives).
  • 📏 Arrays use `.length` for size; 📊 ArrayLists use `.size()` method.

📝 Practice Quiz

Choose the best answer for each question.

1. Which of the following is the correct way to declare and initialize an array of 10 integers in Java?

1. `int[] numbers = {10};`
2. `int numbers[] = new int[10];`
3. `int numbers = new int[10];`
4. `Array numbers = new Array(10);`

2. What will be the output after executing the following Java code snippet?

ArrayList list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add(0, "Cherry");
System.out.println(list.get(1));

1. `Apple`
2. `Banana`
3. `Cherry`
4. `IndexOutOfBoundsException`

3. Given a 2D array `int[][] matrix = {{1, 2, 3}, {4, 5, 6}};`, what is the value of `matrix[1][0]`?

1. `1`
2. `2`
3. `4`
4. `5`

4. What is a primary advantage of using an `ArrayList` over a traditional Java array?

1. `ArrayLists` can store primitive data types directly.
2. `ArrayLists` have a fixed size, which improves performance.
3. `ArrayLists` can dynamically resize themselves.
4. `ArrayLists` allow direct access to elements without using an index.

5. Consider the following `ArrayList`:
`ArrayList nums = new ArrayList<>();`
`nums.add(10); nums.add(20); nums.add(30);`
What is the content of `nums` after `nums.remove(1);` is executed?

1. `[10, 30]`
2. `[20, 30]`
3. `[10, 20]`
4. `[10, 20, 30]` (no change)

6. Which of the following loops correctly iterates through all elements of an `int[] arr = {1, 2, 3, 4, 5};`?

1. for (int i = 1; i <= arr.length; i++) {
       System.out.println(arr[i]);
   }

2. for (int num : arr) {
       System.out.println(num);
   }

3. for (int i = 0; i < arr.length - 1; i++) {
       System.out.println(arr[i]);
   }

4. for (int i = 0; i <= arr.length; i++) {
       System.out.println(arr[i]);
   }

7. Given a 2D array `String[][] names = new String[5][3];`, what does `names.length` represent?

1. The total number of elements in the array.
2. The number of columns (3).
3. The number of rows (5).
4. The length of the first row (which is 3).