Reading 2: Basic Java

A Java List is similar to a Python list. A List contains an ordered collection of zero or more objects, where the same object might appear multiple times. We can add and remove items to and from the List, which will grow and shrink to accomodate its contents.

Example List operations:

In a snapshot diagram, we represent a List as an object with indices drawn as fields:

This list of cities might represent a trip from Boston to Bogotá to Barcelona.

A Map is similar to a Python dictionary. In Python, the keys of a map must be hashable. Java has a similar requirement that we’ll discuss when we confront how equality works between Java objects.

Example Map operations:

In a snapshot diagram, we represent a Map as an object that contains key/value pairs:

This turtles map contains Turtle objects assigned to String keys: Bob, Buckminster, and Buster.

A Set is an unordered collection of zero or more unique objects. Like a mathematical set or a Python set – and unlike a List – an object cannot appear in a set multiple times. Either it’s in or it’s out. Like the keys of a map, the objects in a Python set must be hashable, and Java has a similar requirement.

Example Set operations:

In a snapshot diagram, we represent a Set as an object with no-name fields:

Here we have a set of integers, in no particular order: 42, 1024, and -7.

Python provides convenient syntax for creating lists:

lst = [ "a", "b", "c" ]

And maps:

map = { "apple": 5, "banana": 7 }

Java does not. It does provide a literal syntax for arrays:

String[] arr = { "a", "b", "c" };

But this creates an array, not a List. We can use the utility function Arrays.asList to create a List from the array:

Arrays.asList(new String[] { "a", "b", "c" })

… or directly from arguments:

Arrays.asList("a", "b", "c")

A List created with Arrays.asList does come with a restriction: its length is fixed.

Unlike Python collection types, with Java collections we can restrict the type of objects contained in the collection. When we add an item, the compiler can perform static checking to ensure we only add items of the appropriate type. Then, when we pull out an item, we are guaranteed that its type will be what we expect.

Here’s the syntax for declaring some variables to hold collections:

List<String> cities;        // a List of Strings
Set<Integer> numbers;       // a Set of Integers
Map<String,Turtle> turtles; // a Map with String keys and Turtle values

Because of the way generics work, we cannot create a collection of primitive types. For example, Set<int> does not work. However, as we saw earlier, ints have an Integer wrapper we can use (e.g. Set<Integer> numbers).

In order to make it easier to use collections of these wrapper types, Java does some automatic conversion. If we have declared List<Integer> sequence, this code works:

sequence.add(5);              // add 5 to the sequence
int second = sequence.get(1); // get the second element

As we’ll see soon enough, Java helps us distinguish between the specification of a type – what does it do? – and the implementation – what is the code?

List, Set, and Map are all interfaces: they define how these respective types work, but they don’t provide implementation code. There are several advantages, but one potential advantage is that we, the users of these types, get to choose different implementations in different situations.

Here’s how to create some actual Lists:

List<String> firstNames = new ArrayList<String>();
List<String> lastNames = new LinkedList<String>();

If the generic type parameters are the same on the left and right, Java can infer what’s going on and save us some typing:

List<String> firstNames = new ArrayList<>();
List<String> lastNames = new LinkedList<>();

ArrayList and LinkedList are two implementations of List. Both provide all the operations of List, and those operations must work as described in the documentation for List. In this example, firstNames and lastNames will behave the same way; if we swapped which one used ArrayList vs. LinkedList, our code will not break.

Unfortunately, this ability to choose is also a burden: we didn’t care how Python lists worked, why should we care whether our Java lists are ArrayLists or LinkedLists? Since the only difference is performance, for 6.031 we don’t.

When in doubt, use ArrayList.

HashSet is our default choice for Sets:

Set<Integer> numbers = new HashSet<>();

Java also provides sorted sets with the TreeSet implementation.

And for a Map the default choice is HashMap:

Map<String,Turtle> turtles = new HashMap<>();

So maybe we have:

List<String> cities        = new ArrayList<>();
Set<Integer> numbers       = new HashSet<>();
Map<String,Turtle> turtles = new HashMap<>();

A very common task is iterating through our cities/numbers/turtles/etc.

In Python:

for city in cities:
    print city

for num in numbers:
    print num

for key in turtles:
    print "%s: %s" % (key, turtles[key])

Java provides a similar syntax for iterating over the items in Lists and Sets.

Here’s the Java:

for (String city : cities) {
    System.out.println(city);
}

for (int num : numbers) {
    System.out.println(num);
}

We can’t iterate over Maps themselves this way, but we can iterate over the keys as we did in Python:

for (String key : turtles.keySet()) {
    System.out.println(key + ": " + turtles.get(key));
}

Under the hood this kind of for loop uses an Iterator, a design pattern we’ll see later in the class.

Warning: be careful not to mutate a collection while you’re iterating over it. Adding, removing, or replacing elements disrupts the iteration and can even cause your program to crash. We’ll discuss the reason in more detail in a future class. Note that this warning applies to Python as well. The code below does not do what you might expect:

numbers = [100,200,300]
for num in numbers:
    numbers.remove(num) # danger!!! mutates the list we're iterating over
print(numbers) # list should be empty here -- is it?

Iterating with indices

If you want to, Java provides different for loops that we can use to iterate through a list using its indices:

for (int ii = 0; ii < cities.size(); ii++) {
    System.out.println(cities.get(ii));
}

Unless we actually need the index value ii, this code is verbose and has more places for bugs to hide. Avoid.

Map<String, Double> treasures = new HashMap<>();
String x = "palm";
treasures.put("beach", 25.);
treasures.put("palm", 50.);
treasures.put("cove", 75.);
treasures.put("x", 100.);
treasures.put("palm", treasures.get("palm") + treasures.size());
treasures.remove("beach");
double found = 0;
for (double treasure : treasures.values()) {
    found += treasure;
}

These detailed descriptions are specifications. They allow us to use tools like String, Map, or BufferedReader without having to read or understand the code that implements them.

Reading, writing, understanding, and analyzing specifications will be one of our first major undertakings in 6.031, starting in a few classes.

Map<String, TreasureChest> treasures = new HashMap<>();
treasures.put("beach", new TreasureChest(25));
TreasureChest result = treasures.putIfAbsent("beach", new TreasureChest(75));

Map<String, String> translations = new HashMap<>();
translations.put("green", "verde");
??? result = translations.replace("green", "verde", "ahdar");