All Flashcards
What are the differences between using a regular for loop and an enhanced for loop to traverse an ArrayList?
Regular for loop: Requires manual index management, allows modifications to the ArrayList during traversal. Enhanced for loop: Simpler syntax, does not allow modifications to the ArrayList during traversal.
What are the differences between modifying an ArrayList using set() within a for loop vs. modifying the enhanced for loop variable?
set(): Changes the actual element in the ArrayList. Enhanced for loop variable modification: Only changes the loop variable, not the ArrayList element (pass-by-value).
What are the differences between handling IndexOutOfBoundsException and ConcurrentModificationException?
IndexOutOfBoundsException: Occurs due to invalid index access. ConcurrentModificationException: Occurs due to structural modification during enhanced for loop traversal.
Compare the performance implications of adding elements at the end versus the beginning of an ArrayList.
Adding at the end: Generally faster, O(1) amortized time. Adding at the beginning: Slower, O(n) time due to element shifting.
Compare the use of removeIf() with a regular for loop for removing elements from an ArrayList based on a condition.
removeIf(): More concise, uses lambda expressions. Regular for loop: More control over the removal process and index management.
What are the differences between ArrayList and a standard Java array when traversing and modifying elements?
ArrayList: Dynamic size, uses get() and set() methods. Array: Fixed size, uses bracket notation for access and modification.
Compare the efficiency of searching for an element in an ArrayList using a loop versus using the contains() method.
Loop: Requires manual iteration, O(n) time complexity. contains(): Uses built-in optimized search, potentially faster in some implementations.
What are the differences between using a while loop and a for loop to traverse an ArrayList?
While loop: Requires manual initialization and increment of the index. For loop: More concise and manages index automatically.
Compare the readability and maintainability of using streams and lambda expressions versus traditional loops for processing ArrayList elements.
Streams and lambdas: More concise and declarative, can improve readability. Traditional loops: More verbose, but can be easier to understand for complex logic.
What are the differences between using Iterator and enhanced for loop for traversing an ArrayList?
Iterator: Allows removing elements during traversal using iterator.remove(). Enhanced for loop: More concise but does not allow removing elements.
Why use get() instead of bracket notation with ArrayLists?
ArrayLists are objects, not primitive arrays. get() is the method to access elements.
Why does removing elements during traversal require special care?
Removing shifts elements, potentially skipping the next element if the index isn't adjusted.
Why does adding elements during traversal require special care?
Adding elements shifts elements, potentially causing infinite loops if the index isn't adjusted correctly.
Why can't you modify an ArrayList's size using an enhanced for loop?
Enhanced for loops rely on iterators, which don't allow structural modifications during iteration.
Why is i-- used after removing an element?
To account for the shift in elements after removal, ensuring the next element is checked.
Why is i++ used after adding an element?
To account for the shift in elements after insertion, ensuring the next element is checked.
How does the size() method behave when adding or removing elements during traversal?
The size() method dynamically updates to reflect the current number of elements in the ArrayList.
What happens if you try to access an index outside the range of an ArrayList?
An IndexOutOfBoundsException is thrown.
What is the primary difference between traversing an array and an ArrayList using a for loop?
Arrays use bracket notation and the length property, while ArrayLists use the get() and size() methods.
In what scenario is it appropriate to use a regular for loop instead of an enhanced for loop when traversing an ArrayList?
When you need to modify the ArrayList's structure (add or remove elements) during traversal.
What is the output of the following code?
java
ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));
for (int i = 0; i < nums.size(); i++) {
System.out.print(nums.get(i) + " ");
}
1 2 3
What is the output of the following code?
java
ArrayList<String> words = new ArrayList<>(Arrays.asList("hello", "world"));
for (String word : words) {
System.out.print(word + " ");
}
hello world
Identify the error in the following code:
java
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3));
for (int i = 0; i <= numbers.size(); i++) {
System.out.println(numbers.get(i));
}
IndexOutOfBoundsException. The loop condition should be i < numbers.size().
What is the output of the following code?
java
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(2, 4, 6, 8));
for (int i = 0; i < list.size(); i++) {
if (list.get(i) % 4 == 0) {
list.remove(i);
i--;
}
}
System.out.println(list);
[2, 6]
What is the output of the following code?
java
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 3, 5, 7));
for (int i = 0; i < list.size(); i++) {
if (list.get(i) % 2 != 0) {
list.add(i, list.get(i));
i++;
}
}
System.out.println(list);
[1, 1, 3, 3, 5, 5, 7, 7]
Identify the error in the following code:
java
ArrayList<Integer> nums = new ArrayList<>(Arrays.asList(1, 2, 3));
for (Integer num : nums) {
if (num % 2 == 0) {
nums.remove(num);
}
}
ConcurrentModificationException. Cannot modify the ArrayList while using an enhanced for loop.
What is the output of the following code?
java
ArrayList<String> names = new ArrayList<>(Arrays.asList("Alice", "Bob", "Charlie"));
for (String name : names) {
name = "David";
}
System.out.println(names);
[Alice, Bob, Charlie]
What is the output of the following code?
java
ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 30));
for (int i = 0; i < numbers.size(); i++) {
numbers.set(i, numbers.get(i) / 2);
}
System.out.println(numbers);
[5, 10, 15]
What is the output of the following code?
java
ArrayList<Integer> values = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
values.removeIf(n -> (n % 2 == 0));
System.out.println(values);
[1, 3, 5]
What is the output of the following code?
java
ArrayList<String> colors = new ArrayList<>(Arrays.asList("red", "green", "blue"));
colors.forEach(color -> System.out.print(color.toUpperCase() + " "));
RED GREEN BLUE