8. Arrays

● An array is a collection of similar data types stored in contiguous memory locations. ● Arrays allow storing multiple values under a single variable name.

An array is a data structure that stores a collection of elements of the same type. Instead of declaring separate variables for each value, arrays let you group them together under one name, making it easier to manage and access them. For example, if you need to store multiple scores for students, instead of creating separate variables like score1, score2, and so on, you can use an array named 'scores' to hold all scores in a single structure.

Think of an array like an egg carton. Each egg (element) is similar (they're all eggs) and stored in a specific order (contiguous memory locations). Instead of having separate containers for each egg, you have one carton (the array) that holds them all together, making it convenient to access any egg you want.

● One-dimensional arrays: A linear list of elements. ● Multidimensional arrays: Arrays of arrays, such as two-dimensional arrays (like matrices).

Arrays come in different types based on their structure. One-dimensional arrays are simple lists where you can access elements in a single line, like a list of names. Multidimensional arrays, on the other hand, are more complex and can hold data in multiple dimensions, akin to a grid or a table. For instance, you might have a two-dimensional array to represent a matrix used in mathematics.

Imagine a one-dimensional array as a single row of lockers, each holding one item (like student names). Now, think of a two-dimensional array as a whole array of lockers organized into rows and columns, similar to a spreadsheet where you can find information about each student efficiently.

8.3.1 Declaration int[] numbers; // Declaration of an array of integers 8.3.2 Initialization numbers = new int[5]; // Allocates memory for 5 integers Or combined: int[] numbers = new int[5];

Declaring an array means specifying the type of data it will hold and its name, such as 'int[] numbers'. This tells the program that there is an array of integers called numbers. Initialization is the process of allocating memory for the array elements. By writing 'new int[5]', you're indicating that the array will hold five integer values. You can also combine these steps by declaring and initializing the array in one line.

Think of declaring an array like ordering a set of boxes for storage. You specify the type of box you want (integer, string, etc.) and give it a name (like 'numbers'). When you initialize it, you're actually getting the boxes delivered to your location, ready to be filled with items!

● Each element in an array is accessed using its index. ● Array indices start at 0. Example: numbers[0] = 10; // Assign 10 to first element int x = numbers[2]; // Access third element

Every element in an array can be accessed using its index, which is like its address in that array. Array indices start at 0, which means the first element is at index 0, the second at index 1, and so on. For example, in the array 'numbers', if you want to assign the value 10 to the first element, you write 'numbers[0] = 10'. If you want to retrieve the third element, you write 'int x = numbers[2]'.

Consider an array like a row of mailboxes where each mailbox has a number on it. The first mailbox (index 0) is where you store your first letter (element). To access a letter, you simply go to the mailbox number corresponding to that letter's position!

● Using loops to access or process each element in the array. Example: for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); }

Array traversal involves going through each element of an array, typically using a loop. This allows you to perform operations on each element, like printing them out, calculating totals, or modifying values. In the example provided, a for loop iterates over the index of the array and prints out each element until it reaches the end of the array, which is indicated by 'numbers.length'.

Imagine you are checking each locker in a long row to see if it's empty or occupied. You go from the first locker to the last systematically, making sure you know about every item (element) inside!

● Efficient storage and access of large data sets. ● Simplifies code when dealing with multiple related variables. ● Enables easy manipulation using loops.

Arrays provide several advantages. They allow for efficient storage and access of large amounts of related data since all elements are stored in contiguous memory locations for faster access. This simplifies coding tasks when similar data needs to be handled, reducing redundancy in variable names. Additionally, loops enable you to process entire datasets easily, making operations straightforward.

Think of arrays like an efficient office filing system. Instead of having separate folders for each document, you have one large file (the array) with the documents inside neatly organized, making it easier to find or process any document you need quickly!

● Fixed size: Cannot grow or shrink during program execution. ● Stores only elements of the same data type.

While arrays are useful, they have limitations. Once an array's size is set during initialization, it cannot be changed, meaning you can't add more elements or reduce the number of elements if your needs change later. Additionally, all elements in an array must be of the same data type, so you can't mix integers and strings, for example, in a single array.

Imagine a storage container (the array) that's built with a fixed number of compartments. You can't expand its size or make it smaller after it's built, and you cannot change one compartment to hold a different type of item (like a toy instead of clothes) – it must stay consistent.

int[] arr = {10, 20, 5, 40, 15}; int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } System.out.println("Largest element: " + max);

This example demonstrates how to find the largest number in an array. It starts by creating an array called 'arr' containing several integer values. The program then initializes 'max' to the first element of the array. A loop runs through the rest of the elements, checking each one. If an element larger than the current 'max' is found, it updates 'max' with that new value. In the end, it prints the largest element found in the array.

Think of it as a group competition where each participant holds a trophy, and you want to find out who holds the biggest trophy. You start by looking at the first trophy and then compare it to all others one by one, updating your record every time you find a larger trophy, until all have been checked!

--