Lists

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.

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

<code>import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Creating a List of Strings
        List<String> 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());
    }
}</code>

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.

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.

Here's an example demonstrating the use of ArrayList:

<code>import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<Integer> 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());
    }
}</code>

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?

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.

Here's an example demonstrating various List operations:

<code>import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListOperationsExample {
    public static void main(String[] args) {
        List<String> 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<String> 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());
    }
}</code>

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.

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.

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

<code>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<String> 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<String> iterator = fruits.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // 4. ListIterator (allows backward iteration)
        System.out.println("
Using ListIterator (backward):");
        ListIterator<String> 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);
    }
}</code>

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.

6. Lists Quiz

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.

Here's a template to get you started:

<code>import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Task {
    // Implement Task class
}

class TaskManager {
    private List<Task> 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.");
            }
        }
    }
}</code>

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.