Java Arrays

https://www.facebook.com/Oxus20
oxus20@gmail.com
Java
Arrays
Java Arrays
Zalmai Arman

Outline
Introduction
Array Basics
Copying Arrays
Passing Arrays to Methods
Returning an Array from a Method
(Optional) Variable-Length Argument Lists
The Arrays Class
Two-Dimensional Arrays
(Optional) Multidimensional Arrays

Introduction
» Often you will have to store a large number of values
during the execution of a program.
» Suppose, for instance, that you want to read one hundred
numbers, compute their average, and find out how many
numbers are above the average.
» Your program first reads the numbers and computes their
average, and then compares each number with the average
to determine whether it is above the average.
» The numbers must all be stored in variables in order to
accomplish this task.

Introduction
» You have to declare one hundred variables and repeatedly
write almost identical code one hundred times. From the
standpoint of practicality, it is impossible to write a
program this way.
» An efficient, organized approach is needed. Java and all
other high-level languages provide a data structure, the
array, which stores a fixed-size sequential collection of
elements of the same type.

Array Basics
» An array is used to store a collection of data, but it is often
more useful to think of an array as a collection of variables
of the same type.
» Instead of declaring individual variables, such as number0,
number1, ..., and number99, you declare one array
variable such as numbers and use numbers[0],
numbers[1], and ..., numbers[99] to represent individual
variables.

Array Basics - Declaring Array Variables
» To use an array in a program, you must declare a variable
to reference the array, and you must specify the type of
array the variable can reference. Here is the syntax for
declaring an array variable:
dataType[] arrayRefVar;
or
dataType arrayRefVar[]; //This style is allowed, but not preferred
The following code snippets are examples of this syntax:
double[] myList;
or
double myList[]; //This style is allowed, but not preferred

Array Basics – Creating Arrays
» Unlike declarations for primitive data type variables, the
declaration of an array variable does not allocate any space in
memory for the array.
» Only a storage location for the reference to an array is created.
If a variable does not reference to an array, the value of the
variable is null.
» You cannot assign elements to an array unless it has already
been created.After an array variable is declared, you can create
an array by using the new operator with the following syntax:
arrayRefVar = new dataType[arraySize];

» Declaring an array variable, creating an array, and assigning the
reference of the array to the variable can be combined in one
statement, as shown below:
dataType[] arrayRefVar = new dataType[arraySize];
Here is an example of such a statement:
double[] myList = new double[10];
This statement declares an array variable, myList, creates an array of
ten elements of double type, and assigns its reference to myList.

Array Basics – Array Size and Default Values
» When space for an array is allocated, the array size must
be given, to specify the number of elements that can be
stored in it.The size of an array cannot be changed after
the array is created. Size can be obtained using
arrayRefVar.length. For example, myList.length is 10.
» When an array is created, its elements are assigned the
default value of 0 for the numeric primitive data types,
'u0000' for char types, and false for boolean types.

Array Basics – Array Indexed Variables
» The array elements are accessed through the index.Array
indices are 0-based; that is, they start from 0 to
arrayRefVar.length-1.
» Each element in the array is represented using the
following syntax, known as an indexed variable:
For example, myList[9] represents the last element
in the array myList.

Array Basics – Array Indexed Variables
» After an array is created, an indexed variable can be used
in the same way as a regular variable. For example, the
following code adds the values in myList[0] and myList[1]
to myList[2]:
myList[2] = myList[0] + myList[1];
The following loop assigns 0 to myList[0], 1 to myList[1], and 9 to
myList[9]:
for (int i = 0; i < myList.length; i++)
{
myList[i] = i;
}

Array Basics – Array Initializers
» Java has a shorthand notation, known as the array
initializer, which combines declaring an array, creating an
array, and initializing in one statement using the following
syntax: dataType[] arrayRefVar = {value0, value1, ..., valuek};
For example: double[] myList = {1.9, 2.9, 3.4, 3.5};
This statement declares, creates, and initializes the array myList with
four elements, which is equivalent to the statements shown below:
double[] myList = new double[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
myList[3] = 3.5;

Array Basics – Processing Arrays
» When processing array elements, you will often use a for
loop. Here are the reasons why:
» All of the elements in an array are of the same type.They
are evenly processed in the same fashion by repeatedly
using a loop.
» Since the size of the array is known, it is natural to use a
for loop.
Here are some examples of processing arrays:

» (Initializing arrays with random values)The following loop
initializes the array myList with random values between
0.0 and 99.0: double[] myList = new double[10];
» (Printing arrays)To print an array, you have to print each
element in the array using a loop like the one shown
below.

» For an array of the char[] type, it can be printed using one
print statement. For example, the following code displays
Dallas:
» (Summing all elements) Use a variable named total to
store the sum. Initially total is 0.Add each element in the
array to total, using a loop like this:
double[] myList = {1,2,3,5,8};

» (Finding the largest element) Use a variable named max
to store the largest element. Initially max is myList[0].To
find the largest element in the array myList, compare each
element in myList with max, and update max if the
element is greater than max.

Array Basics – foreach Loops
» JDK 1.5 introduced a new for loop, known as foreach
loop or enhanced for loop, which enables you to traverse
the complete array sequentially without using an index
variable. For example, the following code displays all the
elements in the array myList:
double[] myList = {1.9, 2.9, 3.4, 3.5};

Copying Array
» Often, in a program, you need to duplicate an array or a
part of an array. In such cases you could attempt to use the
assignment statement (=), as follows: list2 = list1;
» This statement does not copy the contents of the array
referenced by list1 to list2, but merely copies the
reference value from list1 to list2.After this statement,
list1 and list2 reference to the same array.

Copying Array
» In Java, you can use assignment statements to copy
primitive data type variables, but not arrays.Assigning one
array variable to another array variable actually copies one
reference to another and makes both variables point to the
same memory location.
» There are three ways to copy arrays:
1. Use a loop to copy individual elements one by one.
2. Use the static arraycopy method in the System class.
3. Use the clone method to copy arrays; this will be introduced in
"Inheritance and Polymorphism."

Copying Array
» You can write a loop to copy every element from the
source array to the corresponding element in the target
array.The following code, for instance, copies
sourceArray to targetArray using a for loop:

Copying Array
» Another approach is to use the arraycopy method in the
java.lang.System class to copy arrays instead of using a
loop.The syntax for arraycopy is shown below:
arraycopy(sourceArray, srcPos, targetArray, tarPos, length);
» The parameters srcPos and tarPos indicate the starting
positions in sourceArray and targetArray, respectively.The
number of elements copied from sourceArray to
targetArray is indicated by length. For example, you can
rewrite the loop using the following statement:
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

» Just as you can pass primitive type values to methods, you
can also pass arrays to methods. For example, the
following method displays the elements in an int array:
» You can invoke it by passing an array. For example, the
following statement invokes the printArray method to
display 3, 1, 2, 6, 4, and 2:

» Java uses pass-by-value to pass arguments to a method.
There are important differences between passing the
values of variables of primitive data types and passing
arrays.
» For an argument of a primitive type, the argument's value
is passed.
» For an argument of an array type, the value of the
argument contains a reference to an array; this reference
is passed to the method.

» Take the following code, for example:
» You will see that after m is invoked, x remains 1, but y[0] is 5555.
This is because y and numbers reference to the same array, although
y and numbers are independent variables

Returning an Array from a Method
» You can pass arrays when invoking a method.A method
may also return an array. For example, the method shown
below returns an array that is the reversal of another
array:

(Optional) Variable-Length Argument List
» JDK 1.5 enables you to pass a variable number of
arguments of the same type to a method.The parameter
in the method is declared as follows:
typeName... parameterName
» In the method declaration, you specify the type followed
by an ellipsis (...) Only one variable-length parameter
may be specified in a method, and this parameter must be
the last parameter.Any regular parameters must precede
it.

(Optional) Variable-Length Argument List
» Java treats a variable-
length parameter as an
array.You can pass an
array or a variable
number of arguments
to a variable-length
parameter.When
invoking a method
with a variable number
of arguments, Java
creates an array and
passes the arguments
to it.

The Array Class
» The java.util.Arrays class contains various static methods for sorting
and searching arrays, comparing arrays, and filling array elements.
These methods are overloaded for all primitive types.
» You can use the sort method to sort a whole array or a partial array.
For example, the following code sorts an array of numbers and an
array of characters:

The Array Class
» You can use the binarySearch method to search for a key in an
array.The array must be pre-sorted in increasing order. If the
key is not in the array, the method returns -(insertion point +1).
For example, the following code searches the keys in an array of
integers and an array of characters:

The Array Class
» You can use the equals method to check whether two arrays are
equal.Two arrays are equal if they have the same contents. In the
following code, list1 and list2 are equal, but list2 and list3 are
not:

The Array Class
» You can use the fill method to fill in the whole array or part of
the array. For example, the following code fills list1 with 5 and
fills 8 into elements list2[1] and list2[3-1]:

» Thus far, you have used one-dimensional arrays to model linear
collections of elements.You can use a two-dimensional array to
represent a matrix or a table.
Declaring Variables of Two-Dimensional Arrays
and Creating Two-Dimensional Arrays
» Here is the syntax for declaring a two-dimensional array:
dataType[][] arrayRefVar;
» As an example, here is how you would declare a two-
dimensional array variable matrix of int values:
int[][] matrix;

» You can create a two-dimensional array of 5 by 5 int values and
assign it to matrix using this syntax:
matrix = new int[5][5];
» Two subscripts are used in a two-dimensional array, one for the
row, and the other for the column.As in a one-dimensional
array, the index for each subscript is of the int type and starts
from 0.

» You can also use an array initializer to declare, create, and
initialize a two-dimensional array. For example, the following
code in (a) creates an array with the specified initial values, This
is equivalent to the code in (b).

Obtaining the Lengths ofTwo-Dimensional Arrays
» A two-dimensional array is actually an array in which each element is
a one-dimensional array.The length of an array x is the number of
elements in the array, which can be obtained using x.length. x[0],
x[1], ..., and x[x.length-1] are arrays.Their lengths can be obtained
using x[0].length, x[1].length, ..., and x[x.length-1].length.
» For example, suppose x = new int[3][4], x[0], x[1], and x[2] are one-
dimensional arrays and each contains four elements, x.length is 3,
and x[0].length, x[1].length, and x[2].length are 4.

Obtaining the Lengths ofTwo-Dimensional Arrays
» A two-dimensional array is a one-dimensional array in which
each element is another one-dimensional array.

Ragged Arrays
» Each row in a two-dimensional array is itself an array.Thus the
rows can have different lengths.An array of this kind is known as
a ragged array. Here is an example of creating a ragged array:
» As can be seen, triangleArray[0].length is 5, triangleArray[1].length is
4, triangleArray[2].length is 3, triangleArray[3].length is 2, and
triangleArray[4].length is 1.

Processing Two-Dimensional Arrays
» (Initializing arrays with random values)The following loop
initializes the array with random values between 0 and 99:

» (Printing arrays)To print a two-dimensional array, you have to
print each element in the array using a loop like the following:

» (Summing all elements) Use a variable named total to store the
sum. Initially total is 0.Add each element in the array to total
using a loop like this:

(Optional)Multidimensional Arrays
» In the preceding section, you used a two-dimensional array to
represent a matrix or a table. Occasionally, you will need to
represent n-dimensional data structures. In Java, you can create
n-dimensional arrays for any integer n.
» The way to declare two-dimensional array variables and create
two-dimensional arrays can be generalized to declare n-
dimensional array variables and create n-dimensional arrays for n
> = 3.
» For example, the following syntax declares a three-dimensional
array variable.
double[][][] num= new double[5][5][5];

(Optional)Multidimensional Arrays

END
46

Java Arrays

More Related Content

What's hot (20)

Similar to Java Arrays (20)

More from OXUS 20 (20)

Recently uploaded (20)

Java Arrays