Java for

Beginners
Arrays and Loops

A beginner-friendly introduction to
fundamental Java concepts

Today's Topics

In this presentation, we'll cover two

fundamental concepts in Java
programming:

Arrays - A way to store

multiple values of the same
type
Loops - Code structures that
let us repeat actions

By the end of this presentation,

you'll understand:

How to create and use arrays

How to work with different
types of loops
When to use each type of
loop

Note: These concepts are building

blocks for all Java programs you'll
write!

What are Arrays?

An array is a container that holds

multiple values of the same type.

Think of an array as a row of

boxes, where:

Each box can hold one value

All boxes must hold the same
type of value (all ints, all
Strings, etc.)
Each box has a number
(called an index) starting
from 0

Array visualization showing boxes

with indexes

Important: In Java, array indexes

start at 0, not 1. So the first
element is at position 0.

Creating Arrays

There are two ways to create

arrays in Java:

Method 1: Declare and

initialize in separate
steps

// Step 1: Declare the array

int[] numbers;

// Step 2: Initialize the ar

numbers = new int[5]; // Cr

// Step 3: Assign values to

numbers[0] = 10; // First e
numbers[1] = 20; // Second
numbers[2] = 30; // Third e
numbers[3] = 40; // Fourth
numbers[4] = 50; // Fifth e

Method 2: Declare and

initialize in one step

// Method 2a: With size

int[] numbers = new int[5];

// Method 2b: With initial v

int[] scores = {95, 87, 98,

Warning: Once an array is

created, its size cannot be
changed!

Accessing Array
Elements

We use the index (position

number) to access array elements:

int[] scores = {95, 87, 98,

// Reading values
int firstScore = scores[0];
int thirdScore = scores[2];

// Changing values
scores[1] = 92; // Changes
scores[4] = 80; // Changes

// Printing a value
System.out.println("First sc

First score: 95

Remember: The last element's

index is always (array length - 1)

For the array scores which has 5

elements:

First element: scores[0]

Last element: scores[4]

Array Length and

Common
Mistakes

To find out how many elements an

array has, use the length
property:

int[] scores = {95, 87, 98,

int numberOfScores = scores

System.out.println("The arra

The array has 5 elements.

Common Array Mistakes

IndexOutOfBoundsException:
Happens when you try to access
an index that doesn't exist

int[] numbers = {10, 20, 30

// WRONG: This will cause an

System.out.println(numbers[3

Always remember:

Array indexes start at 0

The last valid index is
(length - 1)
Array size cannot be
changed after creation

Array Exercises

Exercise 1: Create and

Access an Array

Create an array of 5 favorite

foods. Then print the first and
last food in the array.

Show Solution

Exercise 2: Modify Array

Elements

Create an array of 3 test

scores: 85, 90, and 78. Then:

1. Change the last score to

95
2. Calculate and print the
average of all scores

Show Solution

Introduction to
Loops

Loops are programming structures

that allow us to repeat a block of
code multiple times.

Why Do We Need
Loops?

Imagine you need to print numbers

from 1 to 100. Without loops:

System.out.println(1);
System.out.println(2);
System.out.println(3);
// ... and so on for 100 lin

With loops, we can do this in just a

few lines of code!

Types of Loops in Java

for loop - When you know

exactly how many times to
loop
while loop - When you want
to loop until a condition is
false
do-while loop - Like while,
but always executes at least
once
for-each loop - Specially
designed for collections like
arrays

For Loop

The for loop is ideal when you

know exactly how many times you
want to repeat something.

For Loop Syntax

for (initialization; conditi

// Code to repeat
}

initialization: Executed once

before the loop starts
condition: Checked before
each iteration; loop continues
if true
update: Executed after each
iteration

Example: Printing
Numbers 1-5

for (int i = 1; i <= 5; i++)

System.out.println("Numb
}

Number: 1 Number: 2
Number: 3 Number: 4
Number: 5

How it works:

1. Initialize i = 1
2. Check if i <= 5 (true)
3. Execute the code block (print
number)
4. Update i (i++, which means
i = i + 1)
5. Repeat steps 2-4 until
condition is false

While Loop

The while loop repeats a block of

code as long as a specified
condition is true.

While Loop Syntax

while (condition) {
// Code to repeat
}

The condition is checked

before each iteration. If it's true,
the loop continues; if false, the
loop ends.

Example: Counting
Down from 5

int countdown = 5;

while (countdown > 0) {

System.out.println("Coun
countdown--; // Same as
}

System.out.println("Blast of

Countdown: 5 Countdown: 4
Countdown: 3 Countdown: 2
Countdown: 1 Blast off!

Important: Make sure your

condition will eventually become
false, or you'll create an infinite
loop!

Do-While Loop

The do-while loop is similar to the

while loop, but it guarantees that
the code block executes at least
once.

Do-While Loop Syntax

do {
// Code to repeat
} while (condition);

The key difference is that the

condition is checked after each
iteration, not before.

Example: Menu
Selection

import java.util.Scanner;

public class MenuExample {

public static void main
Scanner scanner = ne
int choice;

do {
System.out.print
System.out.print
System.out.print
System.out.print
System.out.print

choice = scanner

// Process the u
System.out.print

} while (choice != 3

System.out.println("
}

When to use do-while: When you

need to execute the code at least
once before checking the
condition (like showing a menu).

10

For-Each Loop

The for-each loop (also called

enhanced for loop) is specially
designed for iterating through
arrays and collections.

For-Each Loop Syntax

for (elementType element : a

// Code using element
}

This loop automatically iterates

through each element of the array
without needing an index variable.

Example: Iterating
Through an Array

String[] fruits = {"Apple",

// Using for-each loop to pr

for (String fruit : fruits)
System.out.println("I li
}

I like Apple I like

Banana I like Orange I
like Mango I like
Strawberry

Advantage: Simpler, cleaner code

when you need to process all
elements in an array.
Limitation: You can't easily track
the element's position or modify
the array.

11

Using Loops with

Arrays

Loops and arrays work great

together! Here's how to use
different loops with arrays:

1. Using a for loop (with

index)

int[] numbers = {10, 20, 30,

// Print all elements with t

for (int i = 0; i < numbers
System.out.println("Inde
}

Index 0: 10 Index 1: 20
Index 2: 30 Index 3: 40
Index 4: 50

2. Using a for-each loop

(without index)

int[] numbers = {10, 20, 30,

// Print all elements withou

for (int number : numbers)
System.out.println("Valu
}

Value: 10 Value: 20
Value: 30 Value: 40
Value: 50

Tip: Use the regular for loop when

you need the index, and the for-
each loop when you just need the
values.

12

Loop Control
Statements

Sometimes we need to control the

flow of our loops beyond the basic
conditions.

The break Statement

The break statement exits a loop

completely, skipping any remaining
iterations.

// Search for the number 30

int[] numbers = {10, 25, 30,
boolean found = false;

for (int i = 0; i < numbers

if (numbers[i] == 30) {
System.out.println("
found = true;
break; // Exit the
}
}

if (!found) {
System.out.println("30 w
}

The continue
Statement

The continue statement skips

the current iteration and continues
with the next one.

// Print only odd numbers fr

for (int i = 1; i <= 10; i++
if (i % 2 == 0) { // If
continue; // Skip t
}
System.out.println(i + "
}

1 is odd 3 is odd 5 is
odd 7 is odd 9 is odd

13

Loop and Array

Exercises

Exercise 1: Sum of Array

Elements

Write a program that calculates

the sum of all elements in an
integer array.

Use this array: int[]

numbers = {5, 10, 15,
20, 25};

Use a loop to go through each

element and add it to a sum
variable.

Show Solution

Exercise 2: Finding
Maximum Value

Write a program that finds the

largest number in an array.

Use this array: int[]

values = {42, 17, 93,
64, 58};

Start by assuming the first

element is the maximum, then
compare with each element.

Show Solution

Exercise 3: Count Even

Numbers

Write a program that counts

how many even numbers are
in an array.

Use this array: int[]

numbers = {7, 4, 11,
23, 8, 16, 5, 36};

A number is even if dividing

by 2 gives a remainder of 0
(use the % operator).

Show Solution

14

Nested Loops

A nested loop is a loop inside

another loop. The inner loop runs
completely for each iteration of the
outer loop.

Example: Printing a
Pattern

// Print a rectangle pattern

for (int row = 1; row <= 4;
for (int col = 1; col <=
System.out.print("*
}
System.out.println(); /
}

* * * * * * * * * * * * *
* * * * * * *

Nested Loops with

Arrays

Nested loops are great for working

with multi-dimensional arrays
(arrays of arrays):

// A 2D array representing a
int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

// Print all elements with t

for (int row = 0; row < 3; r
for (int col = 0; col <
System.out.println("
}
}

Tip: Nested loops are commonly

used for:

Working with 2D arrays

(matrices, grids, tables)
Creating patterns
Comparing each element
of one array with each
element of another

15

Common Loop
Patterns

Here are some common patterns

you'll use when working with loops:

1. Looping Through
Array in Reverse

int[] numbers = {10, 20, 30,

// Print array in reverse or

for (int i = numbers.length
System.out.println(numbe
}

50 40 30 20 10

2. Looping with Multiple

Variables

// Countdown with two counte

for (int i = 1, j = 10; i <=
System.out.println("i: "
}

3. Processing Every
Other Element

int[] values = {1, 2, 3, 4,

// Process every other eleme

for (int i = 0; i < values.l
System.out.println("Inde
}

16

Choosing the
Right Loop

Each type of loop has its strengths.

Here's when to use each one:

Loop Example
Best For
Type Use Case

When you
know Iterating
exactly how through an
for
many array with
iterations an index
you need

Reading
When you
values from
need to
an array
for- process
(when
each every
index
element in a
doesn't
collection
matter)

When the
loop
Reading
condition
input until a
depends on
while specific
something
value is
other than a
entered
simple
counter

When you
Displaying
need to
do- a menu and
execute the
while getting user
loop at least
input
once

Remember: Often, multiple loop

types can solve the same
problem. Choose the one that
makes your code clearest and
most maintainable.

17

Advanced
Exercises

Exercise 1: Reverse an Array

Write a program that creates a

new array with the elements of
the original array in reverse
order.

Original array: int[]

original = {1, 2, 3, 4,
5};

Expected result: [5, 4, 3,

2, 1]

Show Solution

Exercise 2: Find Duplicates

Write a program that finds and

prints any duplicate values in
an array.

Use this array: int[]

numbers = {4, 2, 7, 4,
8, 3, 7, 1};

Show Solution

18

Summary

Arrays

An array is a collection of
elements of the same type
Array indexes start at 0
Arrays have a fixed size that
cannot be changed after
creation
We can access elements
using their index:
array[index]
The length of an array can be
found using: array.length

Loops

for: For a specific number of

iterations
while: Continue while a
condition is true
do-while: Like while, but
executes at least once
for-each: For iterating
through all elements of an
array

Loop Control

break: Exit a loop early

continue: Skip to the next
iteration

Next steps: Continue practicing

with different array sizes, types,
and loop structures!

19

Thank You!
Keep practicing arrays
and loops

They are building blocks for more

advanced Java programming!