Array Processing Techniques

Storing multiple data in an array is a valuable capability. However, an array's true power lies in processing or manipulating the grouped data. Generally, a programming technique that allows us to work with array elements efficiently is called array processing.

In this code note, we will cover following techniques:

• Introduction
• Populating
• Iterating
• Searching
• Computation

› Introduction

We can create a robust program utilizing a loop and array since an array allows element interactions via incremental index numbers. As you can see from following diagram, each element of the array is accessible via its corresponding index number.

Using loops, we can create matching array indexes for any array. For example, for the array in the above diagram, we can create each of its indexes (0, 1, 2, 3, 4) using for loop:

for(int i = 0; i < 5; i++) {
  System.out.print(i + " ");
}

// --- OUTPUT ---- // 
0 1 2 3 4

As such, all array processing techniques in this note utilize loops.

› Populating

Populating an array with desired data is one of the most used techniques among test engineers. In our automated test cases, we often need a following collection of random test data.

• random usernames and passwords
• random user ages
• random addresses
• random email address
• random social security numbers

We use these random data for all the registration tests where it's needed for signup-forms.

Let's take a look at population an array with few random data we've seen from the list above:

Random usernamesRandom user age

Faker faker = new Faker();

// String array with 300 slots
String[] usernames = new String[300];

for(int i = 0; i < usernames.length; i++) {
    String generatedName = faker.name().username();
    usernames[i] = generatedName;
}

System.out.println( Arrays.toString(userAge) );

The usernames array now contains 300 fake username. Which we can use in our test cases via index. For example, getting 11th fake username is usernames[10]

Faker faker = new Faker();

// integer array with 300 slots
int[] userAge = new int[300];

for(int i = 0; i < userAge.length; i++) {
    int generatedAge = faker.number().numberBetween(0, 101);
    userAge[i] = generatedAge;
}

System.out.println( Arrays.toString(userAge) );

The userAge array now contains 300 random integer values between 0 ~ 100.

› Iterating

Visiting each item in the collection is generally called iteration.   Array element iteration is basis for all the array processing techniques including searching, manipulating, and retrieving.

We can iterate an array in 4 different modes:

• Front to end
• End to front
• Front to middle
• Middle to front

Let's take a look at each iteration mode with code sample.

Front to the EndEnd to the FrontFront to the MiddleEnd to the Middle

We visit each element of an array from first element to the last element.

String[] names = {"Tom", "Jerry", "Alex", "Julie", "Devon"};

for(int i = 0; i < names.length; i++) {
    String name = names[i];
    System.out.println(name);
}

Tom
Jerry
Alex
Julie
Devon

We visit each element of an array from last element to the first element.

String[] names = {"Tom", "Jerry", "Alex", "Julie", "Devon"};

int lastIdx = names.length - 1;

for(int i = lastIdx; i >= 0; i--) {
    String name = names[i];
    System.out.println(name);
}

Devon
Julie
Alex
Jerry
Tom

We visit half of array elements from first element to the middle element.

String[] names = {"Tom", "Jerry", "Alex", "Julie", "Devon"};

int middleIdx = names.length/2;

for(int i = 0; i <= middleIdx; i++) {
    String name = names[i];
    System.out.println(name);
}

Tom
Jerry
Alex

We visit half of array elements from last element to the middle element.

String[] names = {"Tom", "Jerry", "Alex", "Julie", "Devon"};

int middleIdx = names.length/2;
int lastIdx = names.length - 1;

for(int i = lastIdx; i >= middleIdx; i--) {
    String name = names[i];
    System.out.println(name);
}

Devon
Julie
Alex

› Searching

We can search for specific element in the array using control statement like if statement.

String[] names = {"Tom", "Jerry", "Alex", "Julie", "Devon"};

String target = "Julie";

for(int i = 0;  i < names.length; i++) {
    String current = names[i];
    boolean matched = current.equals(target);
    if(matched) {
        System.out.println("target found at index: " + i);
        break;
    }
}

target found at index: 3

One of the other prevalent array searching technique is finding a maximum number in the array.  We will take care of this as follows:

1. Start with first element as max
2. Visit each array element and compare with max
3. If current array element is bigger than max, then current element is the max
4. If current array element is not bigger than max, move on to next element

int[] scores = {90, 12, 4, 123, 324, 13};

int max = scores[0];

for(int i = 0; i < scores.length; i++) {
    int current = scores[i];
    if(current > max)
        max = current;
}

System.out.println("Max number is: " + max);

Max number is: 324

› Computation

Since array is collection of data, we can perform aggregated computation involving all the array elements. We will do this by using arithmetic operators.

We will take a look at following two examples:

• sum of all elements
• average of all elements

▩ Sum of all elements

In order to get sum of all the elements, we add each of the element as we visit them with simple array iteration.

int[] scores = {90, 12, 4, 123, 324, 13};

int sum = 0;
for(int i = 0; i < scores.length; i++) {
    int current = scores[i];
    sum += current;
}

System.out.println("Sum: " + sum);

Sum: 566

▩ Average of all elements

As we get the sum of all elements, we can also get the average of elements by diving sum with array length.

int[] scores = {90, 12, 4, 123, 324, 13};

int sum = 0;
for(int i = 0; i < scores.length; i++) {
    int current = scores[i];
    sum += current;
}

System.out.println("Sum: " + sum);
System.out.println("Avg: " + sum/scores.length);

Sum: 566
Avg: 94