Programming In Java

Array and ArrayList

Lovely Professional University,

Punjab

Arrays
Single dimensional,
Multidimensional and
Jagged Array
Declaring and using ArrayList
class

Lovely Professional University,

Punjab

Array
Definition:
An array is a group/collection of variables of the
same type that are referred to by a common name.
Arrays of any type can be created and may have
one or more dimensions.
A specific element in an array is accessed by its
index (subscript).

Examples:
Collection of numbers
Collection of names
Lovely Professional University,
Punjab

Introducing Arrays
double[] myList = new double[10];
myList

reference

Array reference
variable

Array element at
index 5

myList[0]

5.6

myList[1]

4.5

myList[2]

3.3

myList[3]

13.2

myList[4]

myList[5]

34.33

myList[6]

34

myList[7]

45.45

myList[8]

99.993

11123
Lovely Professional
myList[9] University,
Punjab

Element value

Declaring Array Variables

datatype[] arrayRefVar;
Example:
double[] myList;

datatype arrayRefVar[]; // This

style is //allowed, but not preferred
Example:
double myList[];
Lovely Professional University,
Punjab

Creating Arrays
arrayRefVar = new datatype[arraySize];
Example:
myList = new double[10];

references the first element in

the array.
myList[9] references the last element in
the array.
myList[0]

Lovely Professional University,

Punjab

Declaring and Creating in

One
Step
datatype[] arrayRefVar = new
datatype[arraySize];
double[] myList = new double[10];

datatype arrayRefVar[] = new

datatype[arraySize];
double myList[] = new double[10];

Lovely Professional University,

Punjab

Example
STEP 1 : (Declaration)
int marks[];
marks null
STEP 2: (Memory Allocation)
marks = new int[5];
marks

0
marks[0]

0
marks[1]

0
marks[2]

marks[3]

marks[4]

STEP 3: (Accessing Elements)

marks[0] = 10;
marks

10
marks[0]

0
marks[1]

0
marks[2]

Lovely Professional University,

Punjab

0
marks[3]

0
marks[4]

 Size of an array cant be changed after the array is created.

Default values:
zero (0) for numeric data types,
false for boolean types

Length of an array can be obtained as:

array_ref_var.length
The array's length is available as a final
instance variable length.

Lovely Professional University,

Punjab

Example
class Demo_Array
{
public static void main(String args[])
{

int marks[];
marks = new int[3];
marks[0] = 10;
marks[1] = 35;
marks[2] = 84;

System.out.println(Marks of 2nd student= + marks[1]);

}
}
Lovely Professional University,
Punjab

The Length of an Array

Once an array is created, its size is fixed. It cannot
be changed. You can find its size using
arrayRefVar.length
For example,
myList.length returns 10

Lovely Professional University,

Punjab

Indexed Variables
The array elements are accessed through the index. The
array indices are 0-based, i.e., it starts from 0 to
arrayRefVar.length-1. In the example in Figure , myList holds
ten double values and the indices are from 0 to 9.
Each element in the array is represented using the following
syntax, known as an indexed variable:
arrayRefVar[index];
For Example:
myList[2] = myList[0] + myList[1];

Lovely Professional University,

Punjab

Array Initializers
Declaring, creating, initializing in one step:
double[] myList = {1.9, 2.9, 3.4, 3.5};
This shorthand syntax must be in one statement.
This shorthand notation is equivalent to the following statements:
double[] myList = new double[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
myList[3] = 3.5;

Lovely Professional University,

Punjab

An Array of Characters is Not a String

In the Java programming language, unlike C, an array of
char is not a String, and neither a String nor an array of
char is terminated by '\u0000' (the NUL character).

A String object is immutable, that is, its contents never

change, while an array of char has mutable elements.
The method toCharArray in class String returns an array of
characters containing the same character sequence as a
String.
The class StringBuffer implements useful methods on
mutable arrays of characters.

Lovely Professional University,

Punjab

 The enhanced for loop

iterates through the elements of an array or a collection without
using a counter (thus avoiding the possibility of stepping
outside the array).
The syntax of an enhanced for statement is:
for( type identifier : arrayName) { }
Ex.

Lovely Professional University,

Punjab

class Myarray
{
public static void main(String [] ar)
{
int a[]= {1,2,3,4,5,6,7,8,9};
int total = 0;
for(int i : a)
total +=i;
System.out.println("sum of the elements " +total);
}
}

Lovely Professional University,

Punjab

Copying Arrays
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;

Before the assignment

list2 = list1;
list1

list2

After the assignment

list2 = list1;

Contents
of list1

Contents
of list2

Lovely Professional University,

Punjab

list1

list2
Garbage

Contents
of list1

Contents
of list2

Copying Arrays Cont

There are three ways to copy arrays:
Use a loop to copy individual elements one by
one.
Use the static arraycopy method in the System
class.
Use the clone method to copy arrays;

Lovely Professional University,

Punjab

Copying Arrays Cont

Using a loop:
int[] sourceArray = {2, 3, 1, 5, 10};
int[] targetArray = new
int[sourceArray.length];
for (int i = 0; i < sourceArrays.length; i++)
targetArray[i] = sourceArray[i];

Lovely Professional University,

Punjab

The arraycopy Utility

arraycopy(sourceArray, src_pos,
targetArray, tar_pos, length);
length -- This is the number of array elements to
be copied

Example:

System.arraycopy(sourceArray,
0, targetArray, 0,
sourceArray.length);
Lovely Professional University,
Punjab

public class arr

{
public static void main(String[] args) {
int arr1[] = { 1, 2, 3, 4, 5 };
int arr2[] = new int[arr1.length];
System.arraycopy(arr1, 0, arr2, 1, 3);
System.out.print(arr2[0]
System.out.print(arr2[1]
System.out.print(arr2[2]
System.out.print(arr2[3]
System.out.print(arr2[4]

+
+
+
+
+

"
"
"
"
"

");
");
");
");
");

}
}
Lovely Professional University,
Punjab

The clone method

In Object class
int[] sourceArray = {2, 3, 1, 5, 10};
int[] targetArray = sourceArray.clone();

Lovely Professional University,

Punjab

Passing Arrays to Methods

public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
Invoke the method
int[] list = {3, 1, 2, 6, 4, 2};
printArray(list);
Invoke the method
printArray(new int[]{3, 1, 2, 6, 4, 2});
Anonymous array
Lovely Professional University,
Punjab

 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
arguments value is passed.
For an argument of an array type, the value of the
argument is a reference to an array; this
reference value is passed to the method.
Semantically, it can be best described as pass-bysharing, i.e., the array in the method is the same
as the array being passed. So if you change the
array in the method, you will see the change
outside the method.
Lovely Professional University,
Punjab

public classTest
{ public static void main(String[] args)
{
int x = 1;
// x represents an int
value
int[] y = new int[10];
// y represents an array of int
values
m(x,y) ;
System.out.println("x is "+ x);
System.out.println("y[0] is "+ y[0]);
}
public static void m (int number , int [] numbers)
{
number = 1001;// Assign a new value to number
numbers[0] = 5555;// Assign a new value to numbers[0]
}
}
Lovely Professional University,
Punjab

Lovely Professional University,

Punjab

 Returning an Array from a Method

You can pass arrays when invoking a method. A method may
also return an array.
For example,
public static int[] reverse(int[] list)

{ int[] result = new int[list.length];

for(inti = 0, j = result.length - 1; 5 i < list.length; i++,

j--)

result[j] = list[i];
}
return result;
}
For example, the following statement returns a new array list2
with elements 6,5,4,3,2,1.
int [] list1 = {1,2,3,4,5,6};
int[] list2 = reverse(list1);
Lovely Professional University,
Punjab

 Variable-Length Argument List

We can pass variable number of argument of the same

type of method. The parameter in the method is declared
as follows:
type name parameter name
Java treats variable length parameter as array.
We can pass an array or a variable number of argument to
a variable-length parameter.

Lovely Professional University,

Punjab

public class arr

{
public static void main(String[] args) {
display();
display(1,2,3,4,5,6,7);
display(new int [] {1,2,3});
}
public static void display(int ... a)
{
//System.out.println(a);
if(a.length == 0)
System.out.println("no argument is passed");
else
System.out.println("no of argument is "+a.length );
}
}
Lovely Professional University,
Punjab

Multidimensional Arrays
Declare/Create Two-dimensional Arrays
// Declare array ref var
dataType[][] refVar;
// Create array and assign its reference to
variable
refVar = new dataType[10][10];
// Combine declaration and creation in one
statement
dataType[][] refVar = new dataType[10][10];
// Alternative syntax
dataType refVar[][]
= new dataType[10][10];
Lovely Professional University,
Punjab

Declaring Variables of Two-dimensional

Arrays and Creating Two-dimensional
Arrays
int[][] matrix = new int[10][10];
or
int matrix[][] = new int[10][10];
matrix[0][0] = 3;
for (int i = 0; i < matrix.length; i++){
for (int j = 0; j < matrix[i].length; j++){
matrix[i][j] = (int)(Math.random() * 1000);
}
}
Lovely Professional University,
Punjab

Declaring, Creating, and

Initializing Using Shorthand
Notations
int[][] array =
{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
{10, 11, 12}
};

int[][] array = new int[4][3];

array[0][0] = 1; array[0][1] = 2;
array[0][2] = 3;
array[1][0] = 4; array[1][1] = 5;
array[1][2] = 6;
array[2][0] = 7; array[2][1] = 8;
array[2][2] = 9;
array[3][0] = 10; array[3][1] = 11;
array[3][2]
= 12;
Lovely Professional University,
Punjab

Lengths of Two-dimensional
Arrays
int[][] array = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
{10, 11, 12}
};

array.length
array[0].length
array[1].length
array[2].length
array[3].length

array[4].length
Lovely Professional University,
ArrayIndexOutOfBoundsException
Punjab

class TwoDimArr
{
public static void main(String args[])
{
int twoD[][]= new int[4][5];
int i, j, k = 0;
for(i=0; i<4; i++)
for(j=0; j<5; j++)
{
twoD[i][j] = k;
k++;
}
for(i=0; i<4; i++)
{
for(j=0; j<5; j++)
System.out.print(twoD[i][j] + " ");
System.out.println();
}
}
}
Lovely Professional University,
Punjab

Jagged Arrays
Each row in a two-dimensional array is itself an
array. So, the rows can have different lengths.
Such an array is known as a jagged array. For
example,
int[][] matrix = {
{1, 2, 3, 4, 5},
{2, 3, 4, 5},
{3, 4, 5},
{4, 5},
{5}
};

matrix.length is 5
matrix[0].length is 5
matrix[1].length is 4
matrix[2].length is 3
matrix[3].length is 2
matrix[4].length is 1

Lovely Professional University,

Punjab

 If we dont know the values in a ragged array in

advance, but know the sizes, we can create a
ragged array using the syntax that follows:
int[][] matrix = new int[5][] ;
matrix[0] = new int[5];
matrix[1] = new int[4];
matrix[2] = new int[3];
matrix[3] = new int[2];
matrix[4] = new int[1];
You can now assign values to the array. For
example,
matrix[0][3] = 50;
matrix[4][0] = 45;
Lovely Professional University,
Punjab

The ArrayList Class

We can create an array to store objects. But the arrays size is
fixed once the array is created. Java provides the ArrayList
class that can be used to store an unlimited number of objects.

java.util.ArrayList
+ArrayList()

Creates an empty list.

+add(o: Object) : void

Appends a new element o at the end of this list.

+add(index: int, o: Object) : void

+clear(): void

Adds a new element o at the specified index in this list.

Removes all the elements from this list.

+contains(o: Object): boolean

Returns true if this list contains the element o.

+get(index: int) : Object

+indexOf(o: Object) : int

Returns the element from this list at the specified index.

Returns the index of the first matching element in this list.

+isEmpty(): boolean

Returns true if this list contains no elements.

+lastIndexOf(o: Object) : int

+remove(o: Object): boolean

Returns the index of the last matching element in this list.

+size(): int

Returns the number of elements in this list.

+remove(index: int) : Object

Removes the element at the specified index.

+set(index: int, o: Object) : Object

Sets the element at the specified index.

Removes the element o from this list.

Lovely Professional University,

Punjab

Differences and Similarity between

Arrays and ArrayList

Lovely Professional University,

Punjab

Differences and Similarity between

Arrays and ArrayList Cont

Once an array is created, its size is fixed.

We can access an array element using the square
bracket notation (e.g., a[index]).
When an ArrayList is created, its size is 0.
We cannot use the get and set method if the element is
not in the list.
It is easy to add, insert, and remove elements in a list, but it
is rather complex to add, insert, and remove elements in an
array.
We have to write the code to manipulate the array in order
to perform these operations

Lovely Professional University,

Punjab

import java.util.ArrayList;
class Box {
private double width;
private double height;
private double depth;
Box(Box ob) {
// pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
Box(double len) {
width = height = depth = len;
}
double volume() {
return width * height * depth;
}
}
Lovely Professional University,
Punjab

public class TestArrayList

{
public static void main(String[] args)
{
// Create a list to store cities
java.util.ArrayList cityList = new java.util.ArrayList();
// Add some cities in the list
cityList.add("London");
// cityList now contains [London]
cityList.add("Denver");
// cityList now contains [London, Denver]
cityList.add("Paris");
// cityList now contains [London, Denver, Paris]
cityList.add("Miami");
// cityList now contains [London, Denver, Paris, Miami]
cityList.add("Seoul");
// contains [London, Denver, Paris, Miami, Seoul]
cityList.add("Tokyo");
// contains [London, Denver, Paris, Miami, Seoul, Tokyo]

Lovely Professional University,

Punjab

System.out.println("List size? "+ cityList.size());

System.out.println("Is Miami in the list? "
+cityList.contains("Miami") );
System.out.println("The location of Denver in the list?" +
cityList.indexOf("Denver"));
System.out.println("The location of Uk in the list?" +
cityList.indexOf("Uk"));
System.out.println("Is the list empty? " +cityList.isEmpty() ); //
Print false
// Insert a new city at index 2
cityList.add(2, "Xian");
// contains [London, Denver, Xian, Paris, Miami, Seoul, Tokyo]
// Remove a city from the list
cityList.remove("Miami");
// contains [London, Denver, Xian, Paris, Seoul, Tokyo]
Lovely Professional University,
Punjab

// Remove a city at index 1

cityList.remove(1);
// contains [London, Xian, Paris, Seoul, Tokyo]
// Display the contents in the list
System.out.println(cityList.toString());

/*for(String name : cityList)

{ System.out.println(name);

// Display the contents in the list in reverse order

for (int i = cityList.size() - 1; i >= 0; i--)
System.out.print(cityList.get(i) + " ");
System.out.println();

// Create a list to store two box

java.util.ArrayList list = new java.util.ArrayList();

// Add two box

list.add(new Box(2));
list.add(new Box(3));

}*/

// Display the area of the first box in the list

System.out.println("The Volume of the Box? " + ((Box)list.get(0)).volume());
}
}
Lovely Professional University,
Punjab

Thank You

Lovely Professional University,

Punjab