CS305/503, Spring 2009Basic Java, OOP, and Arrays.

Michael Barnathan

Review Questions• What is one difference between a program and an

algorithm?• What is the asymptotic complexity of each of the

following?1. f(n) = 10n2 - 15n - 22. f(n) = (5n4 + 2n2 - 10n + 2) / 3n3. f(n) = 1 + 2 + 3 + … + n4. f(n) = 12 * sqrt(n+5)5. f(n) = 5n + log(n4)6. f(n) = 5n + log(n)4

7. f(n) = 9n3 + O(n6)8. f(n) = n + Ω(n3)9. f(n) = 9n3 + Θ(n6)10. f(n) = f(n-1) + f(n-2), f(1) = f(2) = 1.

Review Questions• Let a be an array of n numbers. What is the

complexity of the following algorithms?1. System.out.println(a[10]);2. for (int i = 0; i < n; i++)

System.out.println(a[i]);3. for (int i = 0; i < n; i++)

for (int j = 0; j < i; j++)System.out.println(a[i] * a[j]);

4. for (int i = 0; i < n; i++)System.out.println(a[i]);

for (int j = 0; j < n; j++)System.out.println(a[i]);

Review Questions

• Finally, what is the complexity of the following compositions of asymptotics?1. 2 * O(n)2. O(n)2

3. 2O(n2)

4. log(O(n3))

Important things to remember• Nesting two linear functions results in a quadratic function.

– i = 1, j = 1..n, i = 2, j=1..n, …, i = n, j = 1..n– Total number of iterations is n2.

• Taking two linear functions in sequence results in another linear function:– i = 1..n, j = 1..n– Total number of iterations is 2n.

• More generally, nesting multiplies functions (adds exponents):– O(n3) * O(n4) = O(n7)

• While sequences add functions (no change to exponent):– O(n3) + O(n4) = O(n4)

Here’s what we’ll be learning:• Java Review:

– Constants (using final).– Member variables of a class.– Methods and constructors (similar in C++).

• Lack of a destructor, garbage collection.– Static variables (using static, also in C++).– “Public”, “private”, and “package” access and the concept of least

privilege (also in C++).– Encapsulation.

• Theory:– Unsorted Arrays.

• “CRUD” operations: Create/read/update/delete.• Linear searching.• Fixed vs. variable size arrays.

– “Growing”/“Doubling” strategy.

Back to the Guessing Game

• Here’s the code for the game itself:import java.util.Scanner;

class GuessingGame {public static void main(String[] args) {

final int maxnum = 100; //Highest number we're going to guess to.

//I'm thinking of a number...int number = (int) ((Math.random() * maxnum) + 1);

System.out.println("I'm thinking of a number between 1 and " + maxnum);

Scanner readnums = new Scanner(System.in);int guess = 0;while (guess != number) {

System.out.print("What do you think it is? ");guess = readnums.nextInt();

if (guess < number)System.out.println("Nope, higher!");

else if (guess > number)System.out.println("Nope, lower!");

elseSystem.out.println("You got it!");

}}

}

Analysis:

• Let’s play the guessing game. We’ll run through the program line-by-line as we go.

• Not knowing the number, what strategy would you use to minimize the number of guesses you would have to make?– The computer executes an algorithm to verify your

guesses…– And you can execute an algorithm to make them.

• In the worst case, how many guesses must you make by following your strategy?

The other side of the game…• You just manually executed an algorithm to try

and guess the number.• Now let’s try to write a program that will do it in

Java. I’ve “encapsulated” the verification part of the guessing game into the following class:

public class Guesser {public static final int MAXNUM = 100;private final int secret;

//Generate the secret number in the constructor.public Guesser() { secret = (int) (Math.random() * MAXNUM + 1); }

//Returns < if the number is less than the guess, > if greater, = if equal.//This uses the “ternary operator” – which is just a concise way to write if/else statements.public char guessNumber(int guess) { return (secret > guess) ? ‘>’ : ((secret < guess) ? ‘<’ : ‘=’); }

}

This has some new things that we need to know before writing anything.

Member variables.public class Guesser {

public static final int MAXNUM = 100;private final int secret;…

}• Standard local variables are defined inside of a function and “go out of

scope” when the block of code they’re defined in ends.• These are member variables of class Guesser, which means that they

belong to the class, not just a function inside of the class.– They will stay in scope as long as their Guesser object does.– Makes sense: they’re declared outside of any functions.

• They can be public, private, or protected. This determines which classes can access them for both reading and modification.

Final Variables• You declare constants using the final keyword in Java.• Both local and member variables can be final.• final variables may be set only once.

– Once they have a value assigned, it is an error to assign another value to them.• They are like const variables in C, with one important difference:

– They do not need to be declared and initialized in the same statement.• The following is valid in Java:

– final int secret; //Declaration.– secret = 50; //Initialization.

• But the following is not valid in C:– const int secret;– secret = 50; //Nope, you need to set it above.

• The following is not valid in either language:– final int secret = 50; //This is fine.– secret = 51; //No; it must always be 50 now.

• Why is this an important difference?– Constructors.

Methods• A method is a function inside of a class.• All functions in Java are methods.

– You can’t define functions outside of classes, like you could in C/C++.

• Like variables, methods can be public, private, or protected. Like variables, this controls which classes can invoke the methods.

• We’ve already written one: main.• We’ve already invoked several:

– Scanner.nextInt()– Math.random()

• Like member variables, you use the “.” operator to call methods in Java.

Constructors• A constructor is a special method that is called when an object is created.

– They are usually used to initialize an object’s member data.• Constructors always have the same name as their class and never return

anything.– Not even void.

• They can take arguments. A constructor without arguments is called a default constructor.

• Example constructors:class Guesser {

private final int secret;

Guesser() { secret = (int) (Math.random() * MAXNUM + 1); } //Default constructor.Guesser(int s) { secret = s; }

}

• This is why you must be able to set final variables later in Java – they are often set inside of constructors.

• If you don’t specify a constructor, Java will give your class an empty one by default.– If you specify any constructor, even one with arguments, Java won’t give you a

default one anymore. You must implement it yourself if you want it.

Destructors• In C++ and some other object-oriented languages, you can define a

destructor.– This is a function that executes when an object is about to be destroyed (e.g.,

it goes out of scope or is manually deleted using the delete operator).• Java does not permit destructors.

– This is because Java is a garbage collected language:• In C/C++, if you allocated memory with malloc or new, you were responsible for cleaning

it up with free / delete when you were finished.• Failure to do this may result in a memory leak.• Java automatically keeps track of unused objects and deletes them on its own… but does

so on its own schedule.– Because the time at which an object is cleaned up is unpredictable, it is

impossible to accurately guess the program state at this time.– Even something as innocuous as outputting a message might fail.

• Your program may be finished executing and the standard output stream may be closed.• If you need this, you must manually invoke a function to clean up.• However, because Java is garbage collected, you will seldom need to do

this. Java takes care of the cleanup for you.

Access: public, private, package.• Both data and methods have access levels.• 4 levels: private, package, protected, public.

• Private:• Only methods within the same class can access a private member variable or method.

• Package:• Only methods within the same package (group of classes) can access these variables.

• We’ll discuss packages a bit later.• This is the default level; i.e., what you get when you leave out a “private”, “public”, or

“protected” keyword in a declaration.• Protected:

• Only members within the same package or a class that inherits from the same class have access.

• More on inheritance next week.• Public:

• Everyone can access a public member or method.• Concept of least privilege: don’t allow any more access than you need to.• Note to C++ programmers: Java doesn’t have “friend” classes.

Encapsulation

• Classes should stand on their own as much as possible.

• They do this by hiding details of their implementation (using private) and providing access to the class through public methods.– This restricts the actions the caller can take on

objects of your class to the methods you provide.– This is a good thing because you gain more control

over how your code is called and can test for such things as invalid or malicious input.

Static Members• Both variables and methods can be static.• Normal member variables belong to an object.

– 1 object, 1 instance of the member.– Two “Employee” objects would have different names and salaries, for

example.• Static members belong to the class itself.

– 1 instance no matter how many objects.• You can invoke static members using the name of the class, without

creating an object:– For example: Math.random() is static.– So is main!

• Because static methods are not associated with a particular object, they can only access other static members on their own.– But you can declare objects of your class and access their members.

Back to the Gamepublic class Guesser {

public static final int MAXNUM = 100;private final int secret;

//Generate the secret number in the constructor.public Guesser() { secret = (int) (Math.random() * MAXNUM + 1); }

//Returns < if the number is less than the guess, > if greater, = if equal.//This uses the “ternary operator” – which is just a concise way to write if/else statements.public char guessNumber(int guess) { return (secret > guess) ? ‘>’ : ((secret < guess) ? ‘<’ : ‘=’); }

}

This class is encapsulated. There is no way for you, the caller, to find out the secret other than to guess it.

We already know the algorithm: find the midway point, guess, change the boundaries of the acceptable answers depending on whether the guess was low or high. Can you think of some code that would do it?

Analysis

• When you used this strategy manually, it took logarithmic time. Let’s take a look at the code to see whether this is still true.

Arrays• Reminder: Data structures are models that make certain types of access to your

data easier.• Among the simplest of these models is the array.• Arrays are contiguous homogenously typed addressable collections of data.

– Contiguous: Element 2 immediately succeeds Element 1 in memory.– Homogenous: Every element is of the same data type.– Addressable: You can access an individual item in an array based on its index.

• RAM is actually just one very big array.– Memory addresses are indices into the array.

• Both C and Java have built-in support for arrays.– You’ve seen at least one: String[] args in main.– Arrays in C are just pointers. Java gives you much more.

• When you declare an array in Java, the object gets the size.– Example: Employee[] e = new Employee[10];

• Accessing an array is simple:– System.out.println(e[0]);– The index runs from 0 to size-1.

• The most fundamental difference between arrays in C and Java:– You can get the size: System.out.println(e.length); //Prints 10.

An Array

Data 10 21 44 -13 7 26 28 14Index 0 1 2 3 4 5 6 7

Contiguous: adjacent elements are adjacent in memory.Homogenous: all elements are “int”s.

Size: 8.

A[0] = 10A[4] = 7A[8] will throw an ArrayIndexOutOfBounds exception in Java.

Random Access• CRUD operations: Let’s start with reading.• Reading an array is easy: just use arr[index].

– This is a constant-time (O(1)) operation, no matter what the index is.

– This is possible due to the contiguous and homogenous properties of the array.

• All elements are the same type.• All elements are adjacent in memory.• All Java needs to do is offset sizeof(type) * index from the start of

the array in memory – quick lookup.– This is known as “random access”.

• Because looking up a random element always takes O(1).• And this is why RAM is called “random access memory”.

Insertion on Unsorted Arrays

• Since we don’t care about the order, we can insert at the end.– If we wanted to insert in the middle, we’d need to

shift everything after it down – O(n).

• This is simple: keep a counter of how full the array is and increment it as we go.

• Let’s call it arrcount and initialize it to 0.• We can just say: arr[arrcount++] = newelem;• Since arr[arrcount] is O(1), so is insertion.

Updating

• arr[index] = newval;• Simple, easy, also O(1) due to random access.

Deletion

• Two interpretations:– The book’s: You need to shift everything beyond

the target element down.– Mine: If the order really doesn’t matter, you can

just swap with the last element and decrement the counter you’re using to keep track of the size.

– “Shift everything down” is linear – you may have to move up to n-1 items.

– The swap method is constant-time.

Unsorted arrays seem pretty good.• Insertion at end: O(1).• Insertion in the middle: O(N).• Accessing any element: O(1).• Updating an element: O(1).• Deletion (shift): O(N).• Deletion (swap): O(1).

• Why use anything else?– Using only arrays worked pretty well in VB.– We could end the course now!

Back to reality…• There are some drawbacks, however:

– If you don’t know how large the array is, you’ll have to do one of three things (all of which trade off):

• Underestimate and tell the user he’s out of space (flexibility).• Overestimate and waste space (space).• Grow the array dynamically as it gets larger (time + complexity).

– Searching for an element in the array is linear.

• Access and Search are generally the most frequent/important actions a program will take.– Unless you’re doing a lot of writing; e.g., logging data.– These are the ones we want to optimize, then.

Growing the Array• Idea: when the array runs out of space, make it bigger.• Problem: you can’t resize arrays.• Solution: create a new, larger array and copy.• Double the current size is usually a good choice.

– The overall number of doubles you’ll need to do for n insertions is O(log n).

• The algorithm:– Create a new array of size n*2: O(1).– Copy the data to the new array: O(n).– Refer the variable to the new array: O(1).

• There is a very useful Java class that will do this for you.– Look up the Vector class in the Java API.– We’ll cover these so-called “container classes” later on.

Growing the Array

Data 10 21 44 -13Index 0 1 2 3

Data 10 21 44 -13 7 26 28 14Index 0 1 2 3 4 5 6 7

A =

B =A =

Linear Search

• What’s the problem with searching an unsorted array?

Data 10 21 44 -13 7 26 28 14Index 0 1 2 3 4 5 6 7

Worst case: Find 15.

Found it?

No.

• We have to search every element: O(n).

Linear search: The Algorithm.

• You should be able to figure this one out.• It’s very intuitive.Object[] arr;for (int i = 0; i < arr.length; i++) {

if (arr[i].equals(target))return i;

}

return -1; //“Sentinel” value; not found.

Binary Search: A Better Way

• If you know the array is sorted, it’s possible to search it in O(log n) time.

• This works using the same principle as the guessing game:– Eliminate half of the array on each try.

• There are some tradeoffs to sorting the array.– See what I mean? Tradeoffs are everywhere!

• We’ll discuss this more next week.

Fin.• This is really the end. To re-post slide #14:• The lesson:

– The principles of Java owe an intellectual heritage to C++. Much of “progress” is successive copying with some changes. Your existing knowledge will be useful to you when learning new techniques.

• Next class: Searching, basic sorting, sorted arrays, and intro. to recursion.

• Assignment 1: Design an automatic guessing game.• Due Thursday, 12/29.• Rather than having the user guess the number, have the program try to guess it according to

the strategy we discussed.• Keep track of the number of guesses required. Run the program several times and report the

average and worst number of guesses. Does this agree with our worst-case assumption of log(n)? (The base-2 log of 100 is 6.64. There’s no such thing as .64 of a guess, so round to 7).

• Try varying the maximum number the program will choose up to. How do the average and worst number of guesses increase with the input? Do they increase logarithmically?

• Remember, in CS, logarithms are base 2. To do base 2 logs on a calculator, use log(x) / log(2).• You may use the Guesser class that I provided.• Contact me with any questions.