Chapter 7 Arrays

Question 1

Declaring Array Variables: (syntax)

Answer 1

datatype[] arrayRefVar;

ex: double[] myList;

Question 2

Creating Arrays: (syntax)

Answer 2

datatype[] arrayRefVar = new datatype[arraySize];

ex:
double[] myList = new double[10];

myList[0] = the FIRST element in the array
myList[9] = is the last element in the array[10]

Question 3

The length of an array: (syntax)

Answer 3

Find size using:

arrayRefVar.length

Find last index using:

arrayRefVar.length-1

*An out of bounds error will occur if you attempt to reference elements beyond the bounds of an array

Question 4

Default values:
When an array is created, its elements are assigned the default value of:

Answer 4

0 for numeric primitive tyoes
‘\u0000’ for char types
false for boolean types

Question 5

Indexed Variables/using them

Answer 5

The. number in the brackets. Can be used like regular variables.

arrayRefVar[index];
myList[2] = myList[0] + myList[1];

Question 6

Declaring, creating, and initializing using the shorthand notation

Answer 6

double[] myList = {1.9, 2.9, 3.4, 3.5};

Question 7

8 Ways of processing arrays

Answer 7

1. Initializing arrays with input values
2. Printing arrays
3. Initializing arrays with random values
4. Summing all elements
5. Finding the largest element
6. Random Shuffling
7. Shifting elements

Question 8

Initializing arrays with input values

Answer 8

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();
}

Question 9

Printing arrays

Answer 9

for (int i = 0; i < myList.length; i++){
System.out.print(myList[i] + “ “);
}
or
for-each
for(int i: myList){
System.out.print(i);
}

Question 10

Initializing arrays with random values:

Answer 10

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

Question 11

Summing all elements

Answer 11

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

Question 12

Finding the largest element

Answer 12

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

Question 13

Random shuffling

Answer 13

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;
}

Question 14

Shifting elements

Answer 14

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 the last position
myList[myList.length - 1] = temp;

Question 15

Enhanced for loop (for each loop)

Display the following code displays all elements in the array myList

*Note you still have to use an index variable if you wish to traverse the array in a different order or change the elements in the array

Answer 15

// The following code displays all elements in the array myList

for (double value: myList){
System.out.println(value);
}

// The syntax is:
for (elementType value: arrayRefVar){
// Process the value
}

Question 16

Copying arrays:

Duplicating an array or part of an array

Answer 16

list2 = list1;

Question 17

Copying arrays:

Using a loop

Answer 17

int[] source array = {2,3,1,5,10};
int[] targetArray = new int [sourceArray.length];

for (int i = 0; i < sourceArrays.length; i++)
targetArray[i] = sourceArray[i];

Question 18

Passing arrays to methods

Answer 18

public static void printArray(int[] array){
for (int i = 0; i < array.length; i++){
System.out.print(array[i] + “ “ );
}
}
// Invoke the method
int[] list = {3,1,2,6,4,2};
printArray(list);

//Invoke the method (anonymous array)
printArray(new int[] {3,1,2,6,4,2});

Question 19

The array copy Utility Syntax

Answer 19

arraycopy(sourceArray, src_pos, targetArray, tar_pos, length);

Question 20

Anonymous array syntax

Answer 20

new dataType[] {literal 1, 2, 3, };

Question 21

Pass by value: Primitive types.

Answer 21

For a parameter of this type the actual value is passed. Changing the value of the local parameter does not affect the value of the variable outside the method.

Question 22

Pass by value: Array types.

Answer 22

For a parameter of this type the value contains a reference to an array; this reference us passed to the method. Any changes to the array that occur inside the method body will effect the original array that was passed as the argument.

Question 23

Heap memory

Answer 23

The JVM stores the array in an area of memory called heap, which is used for dynamic memory allocation where blocks of memory are allocated and freed in arbitrary order.

Question 24

Call stack

Answer 24

Keeps track of method calls. First in last out.

Question 25

swap method

Answer 25

ex swap(int n1, int n2);

Question 26

Returning an array from a method

List {1,2,3,4,5,6} becomes
List 2 {6,5,4,3,2,1}

Answer 26

int[] list1 = {1,2,3,4,5}
int[] list2 = reverse(list1);

public static int[] reverse (int[] list){
int[] result = new int[list.length];

for (int i = 0, j = result.length - 1; i < list.length; i++, j++);{
result[j] = list[i];
}
return result;
}

or

int temp;
for( int i = 0; i < arr.length / 2; i++){
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length -1 - i] = temp;
}
}

Question 27

Variable-length arguments

A variable number of arguments of the same type can be passed to a method and treated as an array.

Answer 27

typeName… parameterName

public class searching{
public static void main (String[] args){
printValues(1,2,3,4,5);
}
public static void printValues(int…arr){
for (int x: arr){
System.out.print(x + “ “);
}
System.out.println();
}
}

Question 28

Searching Arrays:
List the two types

Answer 28

linear search and binary search

Question 29

Searching arrays:

Describe a method for finding a key in the list, such as whether a certain score is included in the list of scores.

Answer 29

public class linear search {
public static int linearSearch(int[] list, int key){
for (int i = 0; i < list.length; i++)
if (key == list[i])
return i;
return -1;
}
}

Question 30

Linear Search (Basic search)

The linear search approach compares the key element, key, sequentially with each element in the array list.

This method continues to do so until the key matches an element in the list or the list is exhausted without a match being found.

Answer 30

If a match is made, the linear search returns the index of the element in the array that matches the key, if no match is found, the search returns -1.

/** The method for finding a key in the list */
public static int linearSearch(int[] list, int key) {
for (int i = 0; i < list.length; i++)
if (key == list[i])
return i;
return -1;
}

Question 31

Binary search

*The elements must already be in ascending order

Narrowing search

Answer 31

The binary search compares the key with the element in the middle of the array

The binary method returns the INDEX of the element in the list that matches the search key if it is contained in the list

Question 32

Binary Search: if the key is less than the middle element

Answer 32

you only have to search the first half of the array

Question 33

Binary search: if the key is equal to the middle element

Answer 33

the search ends with a match

Question 34

Binary search: if the key is greater than the middle element

Answer 34

you only need to search the key in the second element

Question 35

Use binary search to find the key in the list

Answer 35

public static int binarySearch(int[] list, int key){
int low = 0;
int high - list.length - 1;

while (high >= low){
int mid - (low + high) / 2;
if (key < list[mid])
high - mid - 1;
else if (key == list[mid])
return[mid];
else
low - mid + 1;
}
return -1;
}

Question 36

Since binary search is frequently used in programming, Java provides several overloaded binarySearch methods for searching a key in an array of int, double, char, short, long, and float in the

Answer 36

java.util.Arrays class.

int[] list = {2, 4, 7, 10, 11, 45, 50, 59, 60, 66, 69, 70, 79};
System.out.println(“Index is “ +
java.util.Arrays.binarySearch(list, 11));

//return is 4

index = java.util.Arrays.binarySearch(agesOfZombies, age);
if (index >= 0){
System.out.println(“The zombie with the age of “ + age +
“ is at index “ + index);
}else{
System.out.print(“No match”);
}

Question 37

Selection sort definition

Answer 37

Selection sort finds the smallest number in the list and places it in first. Then it finds the smallest number remaining and places it in second, and so on until the list contains only a single number.

Question 38

Selection sort method

Answer 38

public static void selectionSort(double[] list){
for(int i = 0; i < list.length; i++){

//Find the minimum in the length
  double currentmin = list[i];
  int currentMinIndex = i;
  for (int j = i + 1; j < list.length; j++){
    if (currentMin > list[j]){
      currentMin = list[j];
      currentMinIndex = j;
  }
}
// swap list[i] with list[currentMinIndex} if necessary;
   if currentMinIndex != i) {
      list[currentMinIndex] = list[i];
       list[i] = currentMin;
}    } }

Question 39

What is overloading a method

Answer 39

naming two methods with the same name but differentiating by using different parameters

Question 40

Overloading sort methods for arrays of numbers

Answer 40

double[] numbers = {1.1,2.2,3.3,4.4,5.5};

java.util.Arrays.sort(numbers);

Question 41

Overloading sort methods for arrays of chars

Answer 41

char[] chars = {‘a’, ‘A’, ‘4’, ‘F’, ‘D’, ‘P’};
java.util.Arrays.sort(chars);

Question 42

Java 8 multicore for fast sorting

Answer 42

Arrays.parallelSort(list)

Question 43

The method to return a string representation for the list

Answer 43

Arrays.toString(list)

Question 44

Processing command line parameters

(Passing in Casper Dracula Frankenstein in terminal as arguments)

Answer 44

In the main method, get the arguments from args[0], args[1], …, args[n], which corresponds to arg0, arg1, …, in the command line

Question 45

A variable is declared using the syntax:

Answer 45

elementType[] arrayRefVar;

Question 46

Unlike declarations for primitive data type variables, the declaration of an array variables does what:

Answer 46

the declaration of an array does not allocate any space in memory for the array

Question 47

Is an array variable a primitive data type?

Answer 47

No. An array variable contains a reference to an array.

Question 48

You can only assign elements to an array if:

Answer 48

It has already been created.

Question 49

Create a new array:

Answer 49

dataType[] arrayRefVar = new elementType[arraySize];

Question 50

An index (arrayRefVar[index]) must be an:

Answer 50

integer or an integer expression

*this is the syntax for representing each element in the array

Question 51

After an array is created, its size becomes permanent and can be obtained using:

Answer 51

arrayRefVar.length-1

*an out of bounds error will occur if you attempt to reference elements beyond the bounds of an array

Question 52

Index off by one error

Answer 52

mistaking the first element with index 1 instead of 0

Question 53

When an array is created, its elements are assigned the default values of:

Answer 53

0 for numeric and primitive data types
‘\u000’ for char types
false for boolean

Question 54

Java uses short hand notation which is known as the array initializer which combines declaring an array, creating an array, and initializing an array in one statement, using the syntax:

Answer 54

elementType[] arrayRefVar = {value0, value1, …, valuek};

Question 55

When you pass an array argument to a method, you are actually passing the _______ of the array.

Answer 55

reference.

The called method can modify the elements in the callers original array.

Question 56

If an array is sorted, _____ search is more efficient than ______ search for finding an element in the array.

Answer 56

binary search is more efficient than linear search for finding an element in a sorted array.

Question 57

What does the selection sort method do:

Answer 57

Selection sort finds the smallest number in the list and swaps it with the first element.

It then finds the smallest number remaining and swaps it with the first element in the remaining list and so on, until only a single number remains.