Copying an array and changing the size of an array

What is a copy

Definition: copy of a variable

Copy of a variable = an independent variable that contains the exact value of the original variable
Two variables are independent of each other if their values can change independently of each other

Example:

public class Copy1 { public static void main(String[] args) { double a = 3.14; // Original variable double b; b = a; // b is a copy of a System.out.println("a = " + a); System.out.println("b = " + b); b = b+10; // Update the copy must not change the original System.out.println("Values after updating the copy b:"); System.out.println("a = " + a); System.out.println("b = " + b); } }

Output of this program:

a = 3.14 b = 3.14 Values after updating the copy b: a = 3.14 b = 13.14

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Copying an array: how not to copy an array

Consider the following Java program that tries to copy the array a to the array b:

public class Copy1a { public static void main(String[] args) { double[] a = { 1.1, 2.2, 3.3 }; // The original array double[] b; // The copy b = a; // is b a copy of a ?? /* ==================================== Let's do an experiment.... ==================================== */ int i; /* ---------------------------------- Print the values before the update ---------------------------------- */ System.out.println("a array:"); for ( i = 0; i < a.length; i++) System.out.println( a[i] ); System.out.println("b array:"); for ( i = 0; i < b.length; i++) System.out.println( b[i] ); b[0] = b[0]+10; // Update the copy (must not change the original) /* ---------------------------------- Print the values after the update ---------------------------------- */ System.out.println("Values after updating the copy b[0]:"); System.out.println("a array:"); for ( i = 0; i < a.length; i++) System.out.println( a[i] ); System.out.println("b array:"); for ( i = 0; i < b.length; i++) System.out.println( b[i] ); } }

Example Program: (Demo above code)

Prog file: click here

How to run the program:

Right click on link and save in a scratch directory
To compile: javac Copy1a.java
To run: java Copy1a

Output of this program:

a array: 1.1 2.2 3.3 b array: 1.1 2.2 3.3 Values after updating the copy b[0]: a array: 11.1 2.2 3.3 b array: 11.1 2.2 3.3

Observation (conclusion from this experiment):

The value a[0] in the original array a is changed !!!
In fact: the value a[0] is the same as the value b[0]

Conclusions:

The array element identified by the name a[0] is the same array element that is identified by the name b[0]
The statement b = a; did not make a (true) copy of an array

$64,000 question:

How can the array element identified by the name a[0] is the same array element that is identified by the name b[0] ????

The answer follows...

The effect of the assignment statement using reference variables

Recall that:

The definition:
defines a reference variable (that can contain an address):
A reference variable can store the location (address) of an array (that was created by the new operator):

The definition double[] b defines another reference variable (with the name b):
The assignment statement:
will copy the value of variable a (5000 in the example) into the variable b.
Result:
Notice that the array elements can now be accessed through the reference variable b:
The names of the array elements accessed through the reference variable b are:

In other words, the same array elements can be access through two different names:

Specifically:

The first element of the array can be accessed as a[0] or as b[0]
The second element of the array can be accessed as a[1] or as b[1]
The 3rd element of the array can be accessed as a[2] or as b[2]

That's why when we update:
The value in the array element a[0] is also updated
Because it is the same array element !!!

Aliasing

Definition:

Aliasing = using different names to access the same variable
Wikipedia page: click here

Example:

In the above example, the following names are aliases for the same variable (memory location):

How to copy an array in Java

Important fact:

The operation that creates a (new) array is:

new .... ; Such as in: new double[3] ;

In order to copy an array in Java, we must:

Illustration: (copying an array in Java)

Suppose we have an array a:
Create another array named b:

The following for-statement will copy elements from the array a one-by-one into the array b:

int i; for ( i = 0; i < a.length; i++ ) { b[i] = a[i]; // Copy element a[i] into b[i] }

Complete Java example:

public class Copy2 { public static void main(String[] args) { double[] a = { 1.1, 2.2, 3.3 }; // The original array double[] b; // The copy b = new double[a.length]; // Create array of same length int i; for ( i = 0; i < a.length; i++ ) { b[i] = a[i]; // Copy each element in array ! } /* ==================================== Let's do the same experiment.... ==================================== */ /* ---------------------------------- Print the values before the update ---------------------------------- */ System.out.println("a array:"); for ( i = 0; i < a.length; i++) System.out.println( a[i] ); System.out.println("b array:"); for ( i = 0; i < b.length; i++) System.out.println( b[i] ); b[0] = b[0]+10; // Update the copy (must not change the original) /* ---------------------------------- Print the values after the update ---------------------------------- */ System.out.println("Values after updating the copy b[0]:"); System.out.println("a array:"); for ( i = 0; i < a.length; i++) System.out.println( a[i] ); System.out.println("b array:"); for ( i = 0; i < b.length; i++) System.out.println( b[i] ); } }

Output of this program:

a array: 1.1 2.2 3.3 b array: 1.1 2.2 3.3 Values after updating the copy b[0]: a array: 1.1 2.2 3.3 b array: 11.1 2.2 3.3

Conclusion: array b is a independent and a true copy of the array b.

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Static and dynamic arrays

Definitions:

Static array = an array name that refers to an array where the number of elements in the array is constant (fixed)
Dynamic array = an array name that refers to an array where the number of elements in the array can be changed

Recall that the length of an array = the number of elements in the array.

The need to change of length of an array:

An array is used to store information on similar item
Example: patient records
We will need to increase the length of an array when the number of information item become larger than the length of the array.

Most programming languages provides only static array - you cannot increase the length of these arrays that are referenced by the array name.
Example programming languages with static arrays:
(But these languages does provide a special pointer arithmetic mechanism to implement dynamic arrays).
The Java programming language (and many scripting languages) provide dynamic arrays that can change their length

Changing an existing address in an array reference variable

Recall: that we can create alias by given b the same address value as the variable a:

Property:

The array element that are accessed through the array reference variable a are always named as:
Similarly, the array element that are accessed through the array reference variable b are always named as:

Now, suppose we have defined 2 arrays (a and b) of different lengths:
Notice that:
We will now change (update) the address stored inside the variable a and study its effects.

Consider the following assignment statement:

a = b ; // Put the value of variable b in variable a

The result of this statement is illustrated in the following figure:

Explanation:

The assignment a = b; will put the value 5024 in the variable a.
This will make a "point to" the same array as the variable b
In other words, it create an alias of the elements b[0], b[1], b[2], b[3]:

More importantly:

The array elements accessed through the variable a are completely different array elements than the original ones !!!
Observe this fact in the following figure:

Experimental proof through a Java program:

public class Copy3 { public static void main(String[] args) { double[] a = {5.1, 2.2, 3.4}; double[] b = {1.2, 4.6, 2.4, 8.1}; /* ------------------------------- Print array a before the change -------------------------------- */ System.out.println("a.length = " + a.length ); for ( int i = 0; i < a.length; i++ ) System.out.println( a[i] ); a = b; // a is now an alias for b /* ------------------------------- Print array a AFTER the change -------------------------------- */ System.out.println("a.length = " + a.length ); for ( int i = 0; i < a.length; i++ ) System.out.println( a[i] ); } }

Output of this program:

a.length = 3 5.1 2.2 3.4 a.length = 4 1.2 4.6 2.4 8.1

You can witness the fact that a is an alias for b.

Example Program: (Demo above code)
- Prog file: click here
How to run the program:
Conclusion:

Inaccessible array elements: "garbage"

There is an important phenomenom that still needs be explained in the previous example.

Consider the situation before we change the reference (address) in the variable a:

Fact:

The array elements highlighted with the cyan color can be accessed through the variable a.
(Similarly, The green-colored array elements can be accessed through the variable b).

Now, consider the situation after we change the reference (address) in the variable a:
Pay attention to the array element highlighted wuth the cyan color:
Fact:
Definition: garbage

Effect of garbage on your running computer program
- When variables become inaccessible (= garbage), the memory cells used by those variables become useless (i.e., wasted memory cells).
- Warning:
  When this happens, the computer program will crash (= exits prematurely).
Garbage collection
- The Java programming system has a built-in utility that reclaim the memory cells used by inaccessible variables (= garbage)
- The garbage collector utility is activated automatically by the Java runtime system when the available memory is lower than a certain threshold.
- Bottom line:
  In other programming languages (such as C/C++), the programmer (that means you) is in fact responsible.

Increasing the length of an array that is accessed by an array reference variable

Problem description:

Suppose we have created an array of 3 elements:
Later in the program, we discover that we need more (say 4) array elements:
How can we increase (= change) the length of an existing array ?
(If we can do this, the array is dynamic; and if we cannot do this, the array is static)

Solution:

We first create a new array of the desired length
Then, we must copy the elements from the old array into the newly created array
Finally, we make the variable a point to the new array.

The steps of the solution in Java statements:

Create a new array of the desired length:
Copy the elements from the old array into the newly created array:
(Using a for-statement !)
Make the variable a point to the new array:
Result: (looking only at the array that is accessed through variable a)
Now compare to what we want to achieve:
Mission accomplished !
(It does not matter that the array elements a[0], a[1], ... are stored in different memory cells, as long as the values in a[0], a[1], ... are preserved !!!)

The array doubling technique

A common way to increase the array size is doubling:

We can use the above procedure to increase the size of the array to any value that we want....

The following algorithm will increase the array size to twice the original size:

double[] a = { .... }; // The original array double[] b; // help variable /* ------------------------------------------------------- Array doubling algorithm: doubling the size of array a ------------------------------------------------------- */ b = new double[ 2*a.length ]; // Make an array twice the size of a for ( int i=0; i < a.length; i++ ) // Copy elem's from old array to new b[i] = a[i]; a = b; // Make a point to the new array