1. Arrays
We often want to organize objects or primitive data in a way that makes them easy to access and change. An array is simple but powerful way to group and organize data. When we have a large amount of information such as a list of 100 names, it is not practical to declare separate variables for each piece of data.
Arrays are objects that help us organize large amounts of information.

2. Arrays An array is an ordered list of values
Each value has a numeric index
scores
The entire array
has a single name
Read slide first:
An array is a list of values. Each value is stored in a numbered position in the array. The number for each position is called an index or a subscript. In Java, array indexes always begin at zero.
An array of size N is indexed from zero to N-1
This array holds 10 values that are indexed from 0 to 9

3. Arrays
A particular value in an array is referenced using the array name followed by the index in brackets
For example, the expression
scores[2]
refers to the value 94 (the 3rd value in the scores array)
That expression represents a place to store a single integer and can be used wherever an integer variable can be used
To get a value in an array, we use the name of the array followed by the index in square brackets.

4. Arrays
For example, an array element can be assigned a value, printed, or used in a calculation:
scores[2] = 89;
scores[first] = scores[first] + 2;
mean = (scores[0] + scores[1])/2;
System.out.println ("Top = " + scores[5]);

5. Arrays The values held in an array are called array elements
An array stores multiple values of the same type (the element type)
The element type can be a primitive type or an object reference
Therefore, we can create an array of integers, or an array of characters, or an array of String objects, etc.
In Java, the array itself is an object
Therefore the name of the array is a object reference variable, and the array itself must be instantiated

6. int[] scores = new int[10];
Declaring Arrays
The scores array could be declared as follows:
int[] scores = new int[10];
The type of the variable scores is int[] (an array of integers)
Note that the type of the array does not specify its size, but each object of that type has a specific size
The reference variable scores is set to a new array object that can hold 10 integers
In Java, arrays are objects. To create an array, we must declare the reference to the array. The array can then be instantiated using the new operator, which reserves memory space to store values. All values stored in an array have the same type. For example, we can create an array that can hold integers or an array that can hold strings but not a array that an hold both integers and strings. An array can hold any primitive type or any object (class) type. A value stored in an array is sometimes called an array element, and the type of the values that an array holds is called the element type of the array.

7. BasicArray.java
The BasicArray program creates an array called list that can hold 15 integers. It then changes the value of the sixth element in the array (at index 5). Finally, it prints all values stored in the array. It is often a good idea to use for loops when handling arrays because the number of positions in the array is constant.
Note that a constant called LIMIT is used in several places in the BasicArray program. This constant is used to declare the size of the array, to control he for loop that initializes the array values, and to control the for loop that prints the values.
Using constants in this way is good practice. It makes a program more readable and easier to change. For instance, if you needed to change the size of the array, you should only have to change one line of code (the constant declaration).
The square brackets used to indicate the index of an array are treated an operator in Java. Therefore, like the + operator the <= operator, the index operator has a precedence In fact, it has the highest precedence of all Java operators.

8. Declaring Arrays Some examples of array declarations:
double[] prices = new double[500];
boolean[] flags;
flags = new boolean[20];
char[] codes = new char[1750];

9. Bounds Checking Once an array is created, it has a fixed size
An index used in an array reference must specify a valid element
That is, the index value must be in bounds (0 to N-1)
The Java interpreter throws an ArrayIndexOutOfBoundsException if an array index is out of bounds
This is called automatic bounds checking

10. System.out.println (codes[count]);
Bounds Checking
For example, if the array codes can hold 100 values, it can be indexed using only the numbers 0 to 99
If count has the value 100, then the following reference will cause an exception to be thrown:
System.out.println (codes[count]);
It’s common to introduce off-by-one errors when using arrays
Bounds checking ensures that an index used to refer to an array element is in range. The Java index operator performs automatic bounds checking.
problem
for (int index=0; index <= 100; index++)
codes[index] = index*50 + epsilon;

11. Bounds Checking
Each array object has a public constant called length that stores the size of the array
It is referenced using the array name:
scores.length
Note that length holds the number of elements, not the largest index

12. ReverseOrder.java
The Reserve Order program reads 10 integers into an array called numbers and then prints them in reverse order. Note that in the this program, the array numbers is declared to have 10 elements and therefore is index from 0 to 9. The index range is controlled in the for loop by using the length field of the array object. You should carefully set the initial value of loop control variables and the conditions that terminate loops to guarantee that all elements are processed and only valid indexes are used to reference an array element. In the second for loop index is set to number.length-1. The length of the array is 10 but there is no “10” index position since the index positions go from 0 to 9. The -1 aligns with the index positions.

13. LetterCount.java
The LetterCount program shown here uses two arrays and a String object The array called upper is used to store the number of times each uppercase alphabetic letter is found in the string. The array called lower stores the number of times each lowercase letter is found.

14. Initializer Lists
An initializer list can be used to instantiate and initialize an array in one step
The values are delimited by braces and separated by commas
Examples:
int[] units = {147, 323, 89, 933, 540,
269, 97, 114, 298, 476};
char[] letterGrades = {'A', 'B', 'C', 'D', ’F'};

15. Initializer Lists Note that when an initializer list is used:
the new operator is not used
no size value is specified
The size of the array is determined by the number of items in the initializer list
An initializer list can only be used only in the array declaration

16. Primes.java
The Primes program stores some prime numbers in an array and prints them. It also demonstrates the use of an initializer list for an array. We see a foreach loop used on the array. This is an appropriate loop because each and every element in the array must be visited and evaluated.

17. Arrays as Parameters
An entire array can be passed as a parameter to a method
Like any other object, the reference to the array is passed, making the formal and actual parameters aliases of each other
Changing an array element within the method changes the original
An array element can be passed to a method as well, and follows the parameter passing rules of that element's type

18. Traversing an Array
Use a for-each loop to access every element in an array
Do not use to remove or replace elements
Can only use a for-each loop with primitive data type arrays
//Return the number of even integers in array arr of integers
public static int countEven (int[] arr) {
int count = 0;
for (int num : arr)
if (num % 2 == 0) //num is even
count++; // updates count if Boolean expression is true
return count; }
To traverse an array means to move through each slot in the array, one at a time. The most common way to perform a traversal is to start with the first index and end with the last index but you could also traverse from the last element to the first.