Activity 5.10 — ArrayLists

Introduction

Activity 5.10

ArrayLists (Dynamic Lists)

Why ArrayLists exist

Arrays work great… until you don’t know how many items you need.
ArrayLists can grow and shrink as your program runs.
Same indexing idea as arrays, but flexible size.

1
// Arrays vs ArrayLists (big idea)
2
// Arrays: fixed size
3
// ArrayLists: size can change
4

5
int[] a = new int[3];
6
// a.length is always 3
7

8
ArrayList<Integer> list = new ArrayList<Integer>();
9
// list.size() changes as you add/remove

Methods you must know

1
// ArrayList methods you must know
2
list.add(value);       // append
3
list.get(index);       // read
4
list.set(index, value);// replace
5
list.remove(index);    // delete by index
6
list.size();           // current length

Size vs length

Arrays use .length
ArrayLists use .size()

1
// Common pitfall
2
// ArrayList uses .size(), not .length
3
for (int i = 0; i < list.size(); i++)
4
{
5
    // ...
6
}

Wrapper classes

ArrayLists store objects, not primitive types. That’s why we use Integer instead of int.

1
// Wrapper classes (why Integer, not int?)
2
ArrayList<int> list;    // not allowed
3
ArrayList<Integer> list; // allowed
4

5
// Integer wraps an int so it can be used as an object.

Traversal options

Indexed loops are best when you need index positions.
For-each loops are best when you only need values.
Removing items during traversal needs special care (next activity).

Remove shifts indexes

When you remove an item, items to the right shift left.

1
// Figure 4 — remove shifts elements left
2
import java.util.ArrayList;
3

4
public class Program
5
{
6
    public static void main(String[] args)
7
    {
8
        ArrayList<String> names = new ArrayList<String>();
9
        names.add("Ava");
10
        names.add("Ben");
11
        names.add("Chris");
12

13
        names.remove(1); // removes "Ben"
14

15
        // Now "Chris" moved to index 1
16
        System.out.println(names);
17
    }
18
}

Today’s practice

Create and modify lists
Compute stats from a numeric list
Build a dynamic scoreboard using parallel lists
Edit a playlist using remove/insert

'F' → Fullscreen

Objectives

Create and modify ArrayList objects using core methods.
Traverse ArrayLists using indexed and for-each loops.
Use parallel ArrayLists to model related data.
Understand how inserting and removing affects indexing.

Activity Tasks

Create a new project named Activity5_10_ArrayLists.
Complete Tasks 1–4.
Use the figures as references when you get stuck.

Figures: Examples

1
// Figure 1 — Create an ArrayList and add items
2
import java.util.ArrayList;
3

4
public class Program
5
{
6
    public static void main(String[] args)
7
    {
8
        ArrayList<String> foods = new ArrayList<String>();
9

10
        foods.add("pizza");
11
        foods.add("tacos");
12
        foods.add("sushi");
13

14
        System.out.println(foods);
15
    }
16
}

1
// Figure 2 — get, set, size
2
import java.util.ArrayList;
3

4
public class Program
5
{
6
    public static void main(String[] args)
7
    {
8
        ArrayList<Integer> scores = new ArrayList<Integer>();
9

10
        scores.add(84);
11
        scores.add(91);
12
        scores.add(76);
13

14
        System.out.println("First score: " + scores.get(0));
15
        System.out.println("Count: " + scores.size());
16

17
        scores.set(1, 100); // replace value at index 1
18
        System.out.println(scores);
19
    }
20
}

1
// Figure 3 — Traversal (indexed vs for-each)
2
import java.util.ArrayList;
3

4
public class Program
5
{
6
    public static void main(String[] args)
7
    {
8
        ArrayList<Integer> nums = new ArrayList<Integer>();
9
        nums.add(4);
10
        nums.add(7);
11
        nums.add(2);
12

13
        // Indexed loop (best when you need the index)
14
        for (int i = 0; i < nums.size(); i++)
15
        {
16
            System.out.println(i + ": " + nums.get(i));
17
        }
18

19
        // For-each loop (best when you only need values)
20
        for (int value : nums)
21
        {
22
            System.out.println(value);
23
        }
24
    }
25
}

1
// Figure 4 — remove shifts elements left
2
import java.util.ArrayList;
3

4
public class Program
5
{
6
    public static void main(String[] args)
7
    {
8
        ArrayList<String> names = new ArrayList<String>();
9
        names.add("Ava");
10
        names.add("Ben");
11
        names.add("Chris");
12

13
        names.remove(1); // removes "Ben"
14

15
        // Now "Chris" moved to index 1
16
        System.out.println(names);
17
    }
18
}

Task 1: ArrayList Basics (Strings)

1
// Task 1 — ArrayList Basics (Strings)
2
//
3
// Create an ArrayList<String> named "movies".
4
// 1) Add 5 movie titles.
5
// 2) Print the entire list.
6
// 3) Print the first movie using get(0).
7
// 4) Replace the third movie (index 2) with a new title using set.
8
// 5) Print the list again.
9

10
import java.util.ArrayList;
11

12
public class Program
13
{
14
    public static void main(String[] args)
15
    {
16
        ArrayList<String> movies = new ArrayList<String>();
17

18
        movies.add("The Incredibles");
19
        movies.add("Spider-Man");
20
        movies.add("Toy Story");
21
        movies.add("Shrek");
22
        movies.add("Star Wars");
23

24
        System.out.println("Movies: " + movies);
25
        System.out.println("First: " + movies.get(0));
26

27
        movies.set(2, "Finding Nemo");
28

29
        System.out.println("Updated: " + movies);
30
    }
31
}

Task 2: Numeric List + Stats

1
// Task 2 — Numeric List + Stats
2
//
3
// Create an ArrayList<Integer> named "temps".
4
// 1) Add 7 temperatures (integers).
5
// 2) Compute and print the average.
6
// 3) Find and print the max temperature.
7
// 4) Count and print how many temps are >= 80.
8
//
9
// Rules:
10
// - Use loops (you choose indexed or for-each).
11
// - Average must be a double.
12

13
import java.util.ArrayList;
14

15
public class Program
16
{
17
    public static void main(String[] args)
18
    {
19
        ArrayList<Integer> temps = new ArrayList<Integer>();
20

21
        temps.add(72);
22
        temps.add(68);
23
        temps.add(75);
24
        temps.add(70);
25
        temps.add(69);
26
        temps.add(82);
27
        temps.add(84);
28

29
        int sum = 0;
30
        int max = temps.get(0);
31
        int hotCount = 0;
32

33
        for (int t : temps)
34
        {
35
            sum += t;
36

37
            if (t > max)
38
            {
39
                max = t;
40
            }
41

42
            if (t >= 80)
43
            {
44
                hotCount++;
45
            }
46
        }
47

48
        double avg = (double) sum / temps.size();
49

50
        System.out.println("Temps: " + temps);
51
        System.out.println("Average: " + avg);
52
        System.out.println("Max: " + max);
53
        System.out.println("Count >= 80: " + hotCount);
54
    }
55
}

Task 3: Search + Update (Scoreboard)

1
// Task 3 — Search + Update (Dynamic Scoreboard)
2
//
3
// Build a "scoreboard" using two parallel ArrayLists:
4
// - ArrayList<String> names
5
// - ArrayList<Integer> scores
6
//
7
// 1) Add 5 players and their scores (same index = same player).
8
// 2) Print the scoreboard (name: score).
9
// 3) Ask the user for a player name.
10
//    - If found, add 10 points to their score.
11
//    - If not found, print "Player not found."
12
// 4) Print the updated scoreboard.
13
//
14
// Hint: use equalsIgnoreCase for name matching.
15

16
import java.util.ArrayList;
17
import java.util.Scanner;
18

19
public class Program
20
{
21
    public static void main(String[] args)
22
    {
23
        ArrayList<String> names = new ArrayList<String>();
24
        ArrayList<Integer> scores = new ArrayList<Integer>();
25

26
        names.add("Ava");
27
        scores.add(40);
28

29
        names.add("Ben");
30
        scores.add(55);
31

32
        names.add("Chris");
33
        scores.add(20);
34

35
        names.add("Dina");
36
        scores.add(65);
37

38
        names.add("Eli");
39
        scores.add(35);
40

41
        System.out.println("Scoreboard:");
42
        printScoreboard(names, scores);
43

44
        Scanner scanner = new Scanner(System.in);
45
        System.out.print("Enter a player name: ");
46
        String target = scanner.nextLine();
47

48
        int index = findIndex(names, target);
49

50
        if (index == -1)
51
        {
52
            System.out.println("Player not found.");
53
        }
54
        else
55
        {
56
            scores.set(index, scores.get(index) + 10);
57
            System.out.println("Added 10 points to " + names.get(index) + "!");
58
        }
59

60
        System.out.println("Updated scoreboard:");
61
        printScoreboard(names, scores);
62

63
        scanner.close();
64
    }
65

66
    public static int findIndex(ArrayList<String> names, String target)
67
    {
68
        for (int i = 0; i < names.size(); i++)
69
        {
70
            if (names.get(i).equalsIgnoreCase(target))
71
            {
72
                return i;
73
            }
74
        }
75

76
        return -1;
77
    }
78

79
    public static void printScoreboard(ArrayList<String> names, ArrayList<Integer> scores)
80
    {
81
        for (int i = 0; i < names.size(); i++)
82
        {
83
            System.out.println(names.get(i) + ": " + scores.get(i));
84
        }
85
    }
86
}

Task 4: Remove + Insert (Playlist)

1
// Task 4 — Remove + Insert (Playlist Editor)
2
//
3
// Create an ArrayList<String> named "playlist".
4
// 1) Add 6 song titles.
5
// 2) Remove the song at index 2.
6
// 3) Insert a new song at index 0.
7
// 4) Print the playlist with indexes like:
8
//    0: SongTitle
9
//    1: SongTitle
10
//    ...
11
//
12
// Hint:
13
// - playlist.add(index, value) inserts and shifts right
14
// - playlist.remove(index) removes and shifts left
15

16
import java.util.ArrayList;
17

18
public class Program
19
{
20
    public static void main(String[] args)
21
    {
22
        ArrayList<String> playlist = new ArrayList<String>();
23

24
        playlist.add("Song A");
25
        playlist.add("Song B");
26
        playlist.add("Song C");
27
        playlist.add("Song D");
28
        playlist.add("Song E");
29
        playlist.add("Song F");
30

31
        playlist.remove(2);
32
        playlist.add(0, "Intro Track");
33

34
        for (int i = 0; i < playlist.size(); i++)
35
        {
36
            System.out.println(i + ": " + playlist.get(i));
37
        }
38
    }
39
}

Sample Output

Your program output should something similar to the sample output below.

Movies: [The Incredibles, Spider-Man, Toy Story, Shrek, Star Wars]
First: The Incredibles
Updated: [The Incredibles, Spider-Man, Finding Nemo, Shrek, Star Wars]

Temps: [72, 68, 75, 70, 69, 82, 84]
Average: 74.28571428571429
Max: 84
Count >= 80: 2

Scoreboard:
Ava: 40
Ben: 55
Chris: 20
Dina: 65
Eli: 35
Enter a player name: Ben
Added 10 points to Ben!
Updated scoreboard:
Ava: 40
Ben: 65
Chris: 20
Dina: 65
Eli: 35

0: Intro Track
1: Song A
2: Song B
3: Song D
4: Song E
5: Song F

Reflection Questions

You may write your reflection answers as comments at the bottom of your code.

Why do ArrayLists use size() instead of length?
What does it mean when we say “remove shifts elements left”?
Why do we use Integer instead of int in an ArrayList?
What is one advantage of an ArrayList over an array?
In Task 3, what does “same index = same record” mean for the two lists?

Submission

Submit your activity and reflection answers to the appropriate dropbox.