Introduction to Arrays

• An array is a data structure that holds a collection of elements of the same data type, stored contiguously in memory.
• Elements are accessed using an identifier and an offset (index).

Opening Problem:

• Reading 100 numbers, computing their average, and determining how many are above average is a common task that arrays help with.

Objectives of Studying Arrays:

• Understand the necessity of arrays in programming.
• Learn to declare array reference variables and create arrays.
• Know how to obtain array size using arrayRefVar.length and understand default array values.
• Access array elements using indexes.
• Declare, create, and initialize arrays using array initializers.
• Program common array operations like displaying, summing, finding min/max, shuffling, and shifting elements.
• Simplify programming using foreach loops.
• Apply arrays in application development.
• Copy contents between arrays.
• Develop methods with array arguments and return values.
• Define methods with variable-length argument lists.
• Search elements using linear or binary search algorithms.
• Sort arrays using the selection sort approach.
• Use methods in the java.util.Arrays class.
• Pass arguments to the main method from the command line.

Declaring Array Variables:

• To declare an array variable, the syntax is datatype[] arrayRefVar; (e.g., double[] myList;).
• Alternatively, datatype arrayRefVar[]; is allowed but less preferred.
• Declaring an array variable does not create the array; it only creates a reference.

Creating Arrays:

• Arrays are created using the new operator, specifying the array size: arrayRefVar = new datatype[arraySize];
  • Example: myList = new double[10]; creates an array of 10 doubles.
• myList[0] references the first element, and myList[9] references the last element in the array.
• Array variables must be created before assigning elements.
• If an array variable does not reference an array, its value is null.

Declaring and Creating Arrays in One Step:

• Arrays can be declared and created in one step: datatype[] arrayRefVar = new datatype[arraySize];
  • Example: double[] myList = new double[10];
• Alternatively, datatype arrayRefVar[] = new datatype[arraySize]; is possible.
  • Example: double myList[] = new double[10];
• These statements declare an array variable, create an array of the specified size, and assign the array's reference to the variable.

Length of an Array:

• Once an array is created, its size is fixed and cannot be changed.
• The length of an array can be found using arrayRefVar.length (e.g., myList.length returns 10).

Default Values:

• When an array is created, its elements are assigned default values:
  • 0 for numeric primitive data types
  • \u0000 for char types (null character)
  • false for boolean types

Indexed Variables:

• Array elements are accessed through an index, which is 0-based (starts from 0).
• The valid indices range from 0 to arrayRefVar.length-1.
• Each element is accessed using arrayRefVar[index]; which is known as an indexed variable.

Using Indexed Variables:

• After creation, an indexed variable can be used like a regular variable.
• For example: myList[2] = myList[0] + myList[1];

Array Initializers:

• Arrays can be declared, created, and initialized in one step using a shorthand notation:
  • Example: double[] myList = {1.9, 2.9, 3.4, 3.5};
• The shorthand syntax must be in one statement.
• double[] myList = {1.9, 2.9, 3.4, 3.5}; is equivalent to:

double[] myList = new double[4];
myList[0] = 1.9;
myList[1] = 2.9;
myList[2] = 3.4;
myList[3] = 3.5;

Caution About Shorthand Notation:

• You have to declare, create, and initialize the array all in one statement when using the shorthand notation.
• Splitting it will cause a syntax error.

Enhanced For Loop (For-Each Loop):

• JDK 1.5 introduced the for loop which enables traversal of the complete array sequentially without using an index variable.
• for (double value: myList) System.out.println(value);
• The syntax is for (elementType value: arrayRefVar) { // Process the value }
• To traverse the array in a different order or change the elements, an index variable must be used.
• Elements are passed by value to the element parameter in the for-each loop, so the loop cannot be used to modify an array.

Processing Arrays:

• Examples of array processing include:
  • Initializing arrays with input values.
  • Initializing arrays with random values.
  • Printing arrays.
  • Summing all elements.
  • Finding the largest element.
  • Finding the index of the largest element.
  • Random shuffling.
  • Shifting elements.

Examples of Array Processing Techniques:

Initializing Arrays with Input Values:

Scanner input = new Scanner(System.in);
System.out.print("Enter " + myList.length + " values: ");
for (int i = 0; i < myList.length; i++)
myList[i] = input.nextDouble();

Initializing Arrays with Random Values:

for (int i = 0; i < myList.length; i++) {
myList[i] = Math.random() * 100;
}

Printing Arrays:

for (int i = 0; i < myList.length; i++) {
System.out.print(myList[i] + " ");
}

Summing all elements:

double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}

Finding the Largest Element:

double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}

Random Shuffling:

for (int i = 0; i < myList.length - 1; i++) {
// Generate an index j randomly
int j = (int)(Math.random() * myList.length);
// Swap myList[i] with myList[j]
double temp = myList[i];
myList[i] = myList[j];
myList[j] = temp;
}

Shifting Elements:

double temp = myList[0]; // Retain the first element
// Shift elements left
for (int i = 1; i < myList.length; i++) {
myList[i - 1] = myList[i];
}
// Move the first element to fill in the last position
myList[myList.length - 1] = temp;