The document provides an overview of arrays in Java, including: - Arrays can hold multiple values of the same type, unlike primitive variables which can only hold one value. - One-dimensional arrays use a single index, while multi-dimensional arrays use two or more indices. - Elements in an array are accessed using their index number, starting from 0. - The size of an array is set when it is declared and cannot be changed, but reference variables can point to different arrays. - Common operations on arrays include initializing values, accessing elements, looping through elements, and copying arrays.

2. Object Oriented Programming (OOP)
Introduction to Arrays

3. Review
 A Conditionally-Controlled Loop repeats…
 as long as a particular condition exists.
 A Count-Controlled Loop repeats…
 a specific number of times.
 A count-controlled loop has three elements
 An initialization expression
 A test expression
 An update expression
 The difference between the prefix and postfix
increment operators is…
 pretest increments before the value of the operand is
evaluated, posttest increments after the value of the
operand is evaluated.

4. Review
 A Sentinel Value is…
 a special value that cannot be mistaken for normal input
that signals that a loop should terminate.
 break in a loop…
 makes the program’s control flow go to the statement
following the loop.
 continue in a loop…
 skips to the next iteration of the loop.
 Java provides a class that generates pseudo-random
numbers called…
 Random

5. Arrays
 So far we have worked primarily with primitive
variables
 One characteristic of primitive variables is that they hold
one value at a time.
 int x = 100 – can only hold one integer value at a time
(100 at this time)
 Imagine that you want to hold the names of 100
people at a time.
 What would you have to do?
 Declare 100 variables, one for each name.
 Better solution: Use Arrays.
 Arrays are complex variables that can hold multiple values of
the same data type.
 Now we can declare a single array that holds all the names.
 In Java, Arrays are objects and behave very similarly
(use new keyword to create the object, has methods,
etc.)

6. There are two types of array:
 Single Dimensional Array (1D Array)
One-dimensional array(1-D): It is a single array that holds multiple
values of the same type.
 Multidimensional Array (nth-D Array)
In such case, data is stored in row and column based index (matrix form).
Types of Arrays

7. One-Dimensional Array (1D)
 To declare an integer array:
int[] numbers;
 It is just like declaring any primitive variable, EXCEPT for the[]
between the data type and the identifier.
 Just like any other object, this does not create the array, it
creates a reference variable that can point to an array.
 To create an array object for this reference variable:
numbers = new int[6];
 The number inside of the square brackets is called the array’s
size declarator.
 An array’s Size Declarator indicates the number of elements, or
values the array can hold.
 Individual values inside of an array are called elements.
 So the numbers array can hold 6 integers.
 You can declare and create on the same line like any other
object:
int[] numbers = new int [6];

8.  The elements in an array are numbered starting
from 0.
 So the first element has index 0.
 The size declarator must be a non-negative
integer expression.
 Often cases we know the size of the array when
writing the code and can just use a literal.
 However, it is common practice to use a constant as the
size declarator.
final int NUM_ELEMENTS = 6;
double[] numbers = new double [NUM_ELEMENTS];
 Once an array is created the size cannot change!
One-Dimensional Array (1D)

9. Accessing Array Elements
 Even though, the array has one name, we can access
the individual elements by their index (or subscript).
 An element’s Index (or Subscript) is a uniquely
identifying number that is used to pinpoint its position in
the array.
 So, if I want a specific element, I use its index.
 Again, indices start at 0.
 When you access an element in the array, you can
use it just like any simple variable of the array’s
declared type.
 The following statement assigns 20 to the first
element in the numbers array:
numbers[0] = 20;
 To access an element of an array, simply use the
array name followed by the element’s index inside of
square brackets.

10. Array Example 1
 New Topics:
 Arrays
class ArrayExample {
public static void main(String[] args) {
int[] age = new int[5];
System.out.println(age[0]);
System.out.println(age[1]);
System.out.println(age[2]);
System.out.println(age[3]);
System.out.println(age[4]);
}
}

11. Array Example 2
 This seems repetitive…
 I have to use a separate segment of code for taking
in the employees hours and for printing the result
out.
 Is there a better way?
 Answer: Yes, using loops.
 Arrays work great with loops, because you can
loop through the elements of the array and
perform operations on them.

12. Bounds Checking and Off-by-One
Errors
 What is the problem with this?
int[] numbers = new int [3];
numbers[5] = 10;
 Answer: The index 5 is out of the bounds defined by the size
declarator.
 Java performs bounds checking at runtime.
 In the case with Java that means that if you attempt to index an
element outside of the array’s bounds, it will throw an exception
(cause an error and terminate your program).
 We will not discuss exceptions in this course.
 What is the problem with this?
int[] numbers = new int [3];
numbers[3] = 10;
 Answer: The index 3 is still out of the array’s bounds.
 Because indexing starts at 0, the last element of the array is the
size of the array minus 1.
 This is called an Off-by-One error.

13. Array Declaration Notes
 You can initialize Arrays just like any other variables.
int[] numbers = {1, 2, 3, 4, 5};
 This array has an implicit size of 5 and the values in the initialization are
indexed from left to right.
 Example: ArrayInitialization.java
 Java also allows for two different syntactical forms for declaring an
array:
int[] numbers;
int numbers[];
 The difference is when you declare multiple arrays on the same
line:
int[] numbers1, numbers2, numbers3;
 This declares three reference variables to integer arrays
int numbers1[], numbers2, numbers3;
 This declares one reference variable to an integer array and two primitive
integer variables
int numbers1[], numbers2[], numbers3[];
 This, again, declares three reference variables to integer arrays

14. Array Elements
 Individual array elements can be treated like any simple
variable of that type.
int[] numbers = new int[5];
int x = 5;
numbers[1] = x + 5;
x = numbers[1] + 20;
numbers[2] = numbers[1] / 5;
numbers[2]++;
 Also, since arrays are objects in Java, they have methods
and data members.
 For instance the length data member holds the number of
elements in the array.
 int size = numbers.length;
 This is helpful for looping through an array.

15. Enhanced for Loop
 The last kind of loop we will be discussing in this
course is called the enhanced for loop.
 The Enhanced for Loop is a special loop that iterates
through the elements in a collection (in this case array)
and allows access to each element.
 Each iteration of the loop corresponds to an element in
the array.
 General Form:
for(dataType elementVariable : array)
block or statement
 dataType – The type of the array
 elementVariable – A variable that holds the value of
the current iteration’s element.
 array – The array in which we are iterating through.

16. Enhanced for Loop Example
 Enhanced for Loop
class EnhancedForLoop {
public static void main(String[] args)
{
int primes[] = { 2, 3, 5, 7, 11, 13,
17, 19, 23, 29};
for (int t: primes) {
System.out.println(t);
}
}
}
Output:
2
3
5
7
11
13
17
19
23
29

17. When NOT To Use the Enhanced
for Loop
 The enhanced for loop is useful for when you
need only all the values of the array, but there are
many situations when you should NOT use it:
1. If you need to change the contents of an array
element
2. If you need to work through the array elements in
reverse order
3. If you need to access some of the array elements,
but not all of them
4. If you need to simultaneously work with two or
more arrays within the loop
5. If you need to refer to the index of a particular
element
 If any of these cases apply, use a regular for
loop.

18. Allowing the User to Specify an
Array’s Size
 Since the size declarator is an integer, you can let
the user enter an integer, and then create an
array of that size.

19. Reassigning Reference Variables
and Array Copying
 As stated before, you cannot change the size of an
array once it has been set.
 You can, however, make the reference variable point to
a new array.
int[] numbers = {1, 2, 3, 4, 5};
numbers = new int [10];
 What is the problem with this?
 Now numbers has no values in it!
 What you need to do is copy the elements of the old
array to the new one, and make the original reference
variable point to the new array:
1. Create a new reference variable
2. Make the new reference variable point to an array of the
newly specified size
3. Use a loop to assign the elements from the old array to the
new one.
4. Assign the new reference variable to the old one.

20. Array Copying Example
 Array Copying
public class ArrayCopying{
public static void main(String[] args) {
int a[] = {1, 8, 3};
// Create an array b[] of same size as a[]
int b[] = new int[a.length];
// Copy elements of a[] to b[]
for (int i=0; i<a.length; i++)
b[i] = a[i];
// Change b[] to verify that b[] is different
// from a[]
b[0]++;
System.out.println("Contents of a[] ");
for (int i=0; i<a.length; i++)
System.out.print(a[i] + " ");
System.out.println("nnContents of b[] ");
for (int i=0; i<b.length; i++)
System.out.print(b[i] + " ");
}
}
Output:
Contents of a[]
1 8 3
Contents of b[]
2 8 3

21. Two-Dimensional Array (2D)
 Syntax to Declare 2D Array in Java :
dataType[ ][ ] arr ; (or)
dataType
dataType
dataType
[ ][ ]arr ; (or)
arr[ ][ ]; (or)
[ ]arr[ ];
Example to instantiate Multidimensional Array inJava:
int[ ][ ] arr=new int[3][3]; //3 row and 3 column
Example to initialize Multidimensional Array in Java:
arr[0][0]=1; arr[0][1]=2; arr[0][2]=3;
arr[1][0]=4; arr[1][1]=5; arr[1][2]=6;
arr[2][0]=7; arr[2][1]=8; arr[2][2]=9;

22. Example
class GFG {
public static void main(String[] args)
{
int[][] arr = { { 1, 2 }, { 3, 4 } };
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
Output:
1 2
3 4

23. Any Question…???