Advanced Java · Week 6

Lists

Step 1 of 7

Java 2 Guided Tutorials - Week 6: Lists

What You'll Learn

Welcome to Week 6 of Java 2! This week, we'll dive into Lists, a fundamental data structure in Java. Lists are ordered collections that allow duplicate elements and provide powerful ways to store and manipulate data.

                    Lesson Overview:
                    Introduction to Lists
ArrayList
List Operations
Iterating Through Lists
Quiz to test your knowledge
Weekly project to apply what you've learned

                

By the end of this week, you'll have a solid understanding of Lists in Java and how to use them effectively in your programs. Let's get started!

1. Introduction to Lists

What are Lists?

In Java, a List is an ordered collection (also known as a sequence) that allows duplicate elements. It is part of the Java Collections Framework and is defined in the java.util package.

                    Key Characteristics of Lists:
                    Ordered collection (elements have a specific order)
Allow duplicate elements
Elements can be accessed by their index
Dynamic size (can grow or shrink as needed)

                

The List interface in Java has several implementations, including ArrayList and LinkedList, which we'll explore in detail.

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Creating a List of Strings
        List fruits = new ArrayList<>();

        // Adding elements to the List
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Printing the List
        System.out.println("Fruits: " + fruits);

        // Accessing elements by index
        System.out.println("First fruit: " + fruits.get(0));

        // Checking if an element exists
        System.out.println("Contains 'Banana': " + fruits.contains("Banana"));

        // Getting the size of the List
        System.out.println("Number of fruits: " + fruits.size());
    }
}

This example demonstrates creating a List, adding elements, accessing elements, and performing basic operations. Try running this code in the compiler below and experiment with different List operations.

Write your code here

Make it print Fruits: [Apple, Banana, Orange] First fruit: Apple Contains 'Banana': true Number of fruits: 3

Did it work?

Your program should print this:

Fruits: [Apple, Banana, Orange]
First fruit: Apple
Contains 'Banana': true
Number of fruits: 3

Paste what you got:

2. ArrayList

Understanding ArrayList

ArrayList is one of the most commonly used List implementations in Java. It's backed by a dynamic array, which means it can grow or shrink as needed.

                    Key Features of ArrayList:
                    Fast random access (constant-time complexity)
Good for storing and accessing data
Inefficient for inserting and removing elements (except at the end)
Not synchronized (not thread-safe)

                

Here's an example demonstrating the use of ArrayList:

import java.util.ArrayList;

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

        // Adding elements
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        System.out.println("ArrayList: " + numbers);

        // Adding an element at a specific index
        numbers.add(1, 15);
        System.out.println("After adding 15 at index 1: " + numbers);

        // Removing an element
        numbers.remove(2);
        System.out.println("After removing element at index 2: " + numbers);

        // Updating an element
        numbers.set(0, 5);
        System.out.println("After updating element at index 0: " + numbers);

        // Checking if an element exists
        System.out.println("Contains 20? " + numbers.contains(20));

        // Getting the size
        System.out.println("Size of ArrayList: " + numbers.size());
    }
}

Try running this code in the compiler and experiment with different ArrayList operations. Can you add more elements or perform other operations on the ArrayList?

Write your code here

Make it print ArrayList: [10, 20, 30] After adding 15 at index 1: [10, 15, 20, 30] After removing element at index 2: [10, 15, 30] After updating element at index 0: [5, 15, 30] Contains 20? false Size of ArrayList: 3

Did it work?

Your program should print this:

ArrayList: [10, 20, 30]
After adding 15 at index 1: [10, 15, 20, 30]
After removing element at index 2: [10, 15, 30]
After updating element at index 0: [5, 15, 30]
Contains 20? false
Size of ArrayList: 3

Paste what you got:

4. List Operations

Common List Operations

Lists in Java provide a rich set of operations for manipulating and accessing data. Let's explore some common operations that can be performed on both ArrayList and LinkedList.

                    Key List Operations:
                    Adding elements
Removing elements
Accessing elements
Searching for elements
Sublist operations
Sorting

                

Here's an example demonstrating various List operations:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListOperationsExample {
    public static void main(String[] args) {
        List colors = new ArrayList<>();

        // Adding elements
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");
        colors.add("Yellow");
        System.out.println("Original list: " + colors);

        // Adding at a specific index
        colors.add(2, "Purple");
        System.out.println("After adding Purple at index 2: " + colors);

        // Removing an element
        colors.remove("Green");
        System.out.println("After removing Green: " + colors);

        // Removing by index
        colors.remove(1);
        System.out.println("After removing element at index 1: " + colors);

        // Checking if an element exists
        System.out.println("Contains Blue? " + colors.contains("Blue"));

        // Getting the index of an element
        System.out.println("Index of Yellow: " + colors.indexOf("Yellow"));

        // Getting a sublist
        List subList = colors.subList(0, 2);
        System.out.println("Sublist (0 to 2): " + subList);

        // Sorting the list
        Collections.sort(colors);
        System.out.println("Sorted list: " + colors);

        // Reversing the list
        Collections.reverse(colors);
        System.out.println("Reversed list: " + colors);

        // Clearing the list
        colors.clear();
        System.out.println("After clearing: " + colors);
        System.out.println("Is the list empty? " + colors.isEmpty());
    }
}

Run this code in the compiler and observe how different List operations affect the collection. Try modifying the code to perform additional operations or use different data types.

Write your code here

Make it print Original list: [Red, Green, Blue, Yellow] After adding Purple at index 2: [Red, Green, Purple, Blue, Yellow] After removing Green: [Red, Purple, Blue, Yellow] After removing element at index 1: [Red, Blue, Yellow] Contains Blue? true Index of Yellow: 2 Sublist (0 to 2): [Red, Blue] Sorted list: [Blue, Red, Yellow] Reversed list: [Yellow, Red, Blue] After clearing: [] Is the list empty? true

Did it work?

Your program should print this:

Original list: [Red, Green, Blue, Yellow]
After adding Purple at index 2: [Red, Green, Purple, Blue, Yellow]
After removing Green: [Red, Purple, Blue, Yellow]
After removing element at index 1: [Red, Blue, Yellow]
Contains Blue? true
Index of Yellow: 2
Sublist (0 to 2): [Red, Blue]
Sorted list: [Blue, Red, Yellow]
Reversed list: [Yellow, Red, Blue]
After clearing: []
Is the list empty? true

Paste what you got:

5. Iterating Through Lists

Ways to Iterate Through Lists

Iterating through a List is a common operation in Java. There are several ways to do this, each with its own advantages and use cases.

                    Common Iteration Methods:
                    For-each loop (enhanced for loop)
Traditional for loop
Iterator
ListIterator
Java 8 forEach() method with lambda expressions

                

Here's an example demonstrating different ways to iterate through a List:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListIterationExample {
    public static void main(String[] args) {
        List fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");
        fruits.add("Date");

        // 1. For-each loop
        System.out.println("Using for-each loop:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 2. Traditional for loop
        System.out.println("
Using traditional for loop:");
        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(fruits.get(i));
        }

        // 3. Iterator
        System.out.println("
Using Iterator:");
        Iterator iterator = fruits.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 4. ListIterator (allows backward iteration)
        System.out.println("
Using ListIterator (backward):");
        ListIterator listIterator = fruits.listIterator(fruits.size());
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

        // 5. Java 8 forEach() method with lambda
        System.out.println("
Using forEach() with lambda:");
        fruits.forEach(fruit -> System.out.println(fruit));

        // or more concisely:
        // fruits.forEach(System.out::println);
    }
}

Run this code in the compiler and observe the different ways of iterating through the List. Each method has its own advantages: - For-each loop is concise and easy to read. - Traditional for loop allows you to use the index if needed. - Iterator is useful when you need to remove elements while iterating. - ListIterator allows bidirectional traversal and modification. - forEach() with lambda is a more functional approach introduced in Java 8. Try modifying the code to perform operations on the elements while iterating, such as filtering or transforming the data.

Write your code here

Make it print Using for-each loop: Apple Banana Cherry Date Using traditional for loop: Apple Banana Cherry Date Using Iterator: Apple Banana Cherry Date Using ListIterator (backward): Date Cherry Banana Apple Using forEach() with lambda: Apple Banana Cherry Date

Did it work?

Your program should print this:

Using for-each loop:
Apple
Banana
Cherry
Date

Using traditional for loop:
Apple
Banana
Cherry
Date

Using Iterator:
Apple
Banana
Cherry
Date

Using ListIterator (backward):
Date
Cherry
Banana
Apple

Using forEach() with lambda:
Apple
Banana
Cherry
Date

Paste what you got:

Quick check

1. Which of the following is NOT a characteristic of Java Lists?
2. Which List implementation is better for frequent insertions and deletions in the middle of the list?
3. Which method is used to add an element at a specific index in a List?

7. Weekly Project: Task Manager

Project Description

For this week's project, you'll create a simple Task Manager application using Lists. This project will help you apply the concepts you've learned about Lists and practice working with user input.

                    Requirements:
                    Create a Task class with properties like title, description, and status (completed or not)
Implement a TaskManager class that uses a List to store Task objects
Include methods to add tasks, mark tasks as completed, remove tasks, and list all tasks
Create a simple menu-driven interface for user interaction
Use appropriate List methods for managing the tasks
Implement error handling for invalid inputs

                

Here's a template to get you started:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Task {
    // Implement Task class
}

class TaskManager {
    private List tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
    }

    // Implement methods for managing tasks
}

public class TaskManagerApp {
    public static void main(String[] args) {
        TaskManager manager = new TaskManager();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("
1. Add Task");
            System.out.println("2. Mark Task as Completed");
            System.out.println("3. Remove Task");
            System.out.println("4. List All Tasks");
            System.out.println("5. Exit");
            System.out.print("Enter your choice: ");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Consume newline

            switch (choice) {
                case 1:
                    // Implement add task
                    break;
                case 2:
                    // Implement mark task as completed
                    break;
                case 3:
                    // Implement remove task
                    break;
                case 4:
                    // Implement list all tasks
                    break;
                case 5:
                    System.out.println("Exiting Task Manager. Goodbye!");
                    return;
                default:
                    System.out.println("Invalid choice. Please try again.");
            }
        }
    }
}

Implement the Task class and the methods in the TaskManager class. Use the List operations we've learned to manage the tasks effectively. Once you've completed the implementation, use the compiler to test your Task Manager application. Make sure to handle different scenarios, such as adding multiple tasks, marking them as completed, and removing tasks.

Write your code here

Make it print 1. Add Task 2. Mark Task as Completed 3. Remove Task 4. List All Tasks 5. Exit Enter your choice: 1 Task added: Buy groceries 1. Add Task 2. Mark Task as Completed 3. Remove Task 4. List All Tasks 5. Exit Enter your choice: 4 Tasks: 1. Buy groceries (Not Completed) 1. Add Task 2. Mark Task as Completed 3. Remove Task 4. List All Tasks 5. Exit Enter your choice: 2 Task marked as completed: Buy groceries 1. Add Task 2. Mark Task as Completed 3. Remove Task 4. List All Tasks 5. Exit Enter your choice: 4 Tasks: 1. Buy groceries (Completed) 1. Add Task 2. Mark Task as Completed 3. Remove Task 4. List All Tasks 5. Exit Enter your choice: 5 Exiting Task Manager. Goodbye!

Did it work?

Your program should print this:

1. Add Task
2. Mark Task as Completed
3. Remove Task
4. List All Tasks
5. Exit
Enter your choice: 1
Task added: Buy groceries
1. Add Task
2. Mark Task as Completed
3. Remove Task
4. List All Tasks
5. Exit
Enter your choice: 4
Tasks:
1. Buy groceries (Not Completed)
1. Add Task
2. Mark Task as Completed
3. Remove Task
4. List All Tasks
5. Exit
Enter your choice: 2
Task marked as completed: Buy groceries
1. Add Task
2. Mark Task as Completed
3. Remove Task
4. List All Tasks
5. Exit
Enter your choice: 4
Tasks:
1. Buy groceries (Completed)
1. Add Task
2. Mark Task as Completed
3. Remove Task
4. List All Tasks
5. Exit
Enter your choice: 5
Exiting Task Manager. Goodbye!

Paste what you got:

PreviousPolymorphism NextRecursion