1.1-Introductie-Programmeren

Theory Lists 2

Competence: I can use arrays alongside ArrayLists and understand the difference between the two types.

Specific learning goals:

• you know what Arrays are as a foundational implementation for lists in programming languages, like Java.
• you know that ArrayLists are based internally on Arrays, but offer more flexibility
• you know the differences between ArrayLists and Arrays:
  • fixed size vs. dynamic size
  • automatic management of elements
  • creation of gaps on element removal
  • efficiency and memory usage
  • how to find the size
• you know that Arrays (also) start at index 0.
• you know how to use Arrays, like adding/removing elements
• you know that the Arrays class can provide utility array handling and operation methods.

The assignments can be found in the separate modules.

Summary

Arrays are the “standard” (basic) implementation for lists in most programming languages. An ArrayList uses (as the name suggests) an array to store data. The reason we use an ArrayList in this module to create our lists instead of an array is mainly for convenience. There are some important differences between an ArrayList and an array:

• Arrays always have a fixed size that you must set when creating the list. The length of the array cannot be changed later without creating an entirely new array. ArrayLists are more flexible as they allow you to add virtually infinite elements to the list, and you don’t need to know in advance how many elements the list will contain. The size depends entirely on the number of elements. Creating a new array and copying existing elements is done for you automatically!
• If you remove an item from an ArrayList (e.g. list.remove(5)) there will be no gap (on position 5). The other elements automatically move around to fill in the empty index again. If you remove an element from an normal array, a “hole” is created which you can/must close again later.
• For arrays you can use primitive types such as int, boolean or char. With ArrayLists you must use the non-primitive variants (Integer, Double, Boolean). This takes a little more time / memory space and is therefore often seen as less efficient.
• If you know in advance exactly which elements will appear in the list (and this is also fixed), creating an array is much easier than creating an ArrayList. This is because you can initialise an array directly with values. An ArrayList cannot do this.

Arrays

You have secretly been working quite a lot with arrays lately. You just (probably) didn’t know it yet! ArrayLists use arrays, as the name suggests.

In Java, an array is the “standard” implementation of a list and works (just like the ArrayList) on the basis of indices. The big difference between the two list types, however, is the use.

Differences with ArrayList

The biggest difference between arrays and ArrayLists is the fact that arrays have a fixed size. This means that if you create an array of size 5, it can only have 5 elements. If you remove an element from an array, you create a “gap” that you need to take into account in your program. An ArrayList is an extension to the array and solves some of these problems for you automatically.

An ArrayList contains an array internally and is designed to solve any problems directly. For example, the ArrayList will automatically create a new array for you if the first one becomes too small and copy the contents from the old to the new array. Also, the ArrayList will automatically make sure that elements that are left in a list after an element is removed or added are put back to a correct index. If you were using an array rather than an ArrayList, you would have had to do all these things yourself.

The fact that an array has a fixed size is both an advantage and a disadvantage. If you know in advance how big a list is going to be (such as a top 10), an array is more efficient to use. If you want to force a total of 10 elements in a list, an array can do this for you automatically. After all, an ArrayList will always be able to grow.

The disadvantage of an array is its lack of ease of use: you have to do the administration yourself (keep track of holes, make sure there is enough room, etc.), so you don’t have any “tools” that can make your life easy. For this module you will therefore often use the ArrayList instead of an array, but since the array occurs so often in programming, it is important that you have seen it once!

Syntax

There are two ways to create a new array. You can create a new (empty) array of a certain size or fill them with values immediately.

// Approach 1 - Direct initialisation of values:
char[] letters = {'a', 'b', 'c', 'd', 'e', 'f' };

// Approach 2 - Leave holes for later:
int[] numbers = new int[6];

Please note the use of the brackets ([]). This is how you create an array of any type. Basically, you can easily create an array of all variables by adding these two brackets to the type. Another example: Person somePerson refers to a single person and Person[] persons suddenly refers to a list of Person instances!

The indexing of an array then goes in the same way as an ArrayList. The first element gets index 0, the second element gets index 1, etc.

Adding an element to an array is the same as assigning a variable a value:

char[] letters = new char[3];

letters[0] = 'a';
letters[1] = 'b';
letters[2] = 'c';

int[] numbers = new int[3];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

If you want to retrieve an element from an array, you do so in the following way:

char someLetter = letters[0]; // Haal de waarde op van index 0 uit de array numbers, dit bevat het character 'a'

int someNumber = numbers[6]; // ERROR! Index 6 bestaat niet!

Finally, you can ask, for example, what the size of an array is. Below is an example that also illustrates the difference with an ArrayList.

int[] arrayNumbers = {1, 2, 3, 4, 5};

ArrayList<Integer> listNumbers = new ArrayList<>();
for(int i = 1; i <= 5; i++) {
    listNumbers.add(i);
}

int arraySize = arrayNumbers.length; // Returns 5
int listSize = listNumbers.size(); // Also returns 5

Note the difference between the two! With an array you use a variable length to retrieve the size. With an ArrayList you use the method size().

Useful link

To make the use of arrays a bit easier, Java has created a whole box of tools that you can use. https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Arrays.html