Python lists

• Lists are built into Python (along with sets, dictionaries, tuples)
• They are easy to create:

  groceries = ["eggs", "bread", "milk"]
  my_fave_things = []

• They can even contain different types of data (probably not a good idea):

  stupid_list = ["Charlywawa", -23, [1, 2.6, 3], True]

• Python has operators, functions and methods to access elements of the list, to grow the list, to shrink the list, etc, etc:

  print( groceries[1] )
  groceries[2] = "fat-free milk"
  groceries = groceries + ["bacon"]
  print( len( my_fave_things ) )
  my_fave_things.append( "Java" )
  my_fave_things.insert( "Python", 0 )
  groceries.remove("eggs")
  stupid_list.pop(2)

Arrays in Java

• Java does not have lists (or sets, tupes or dictionaries) built in
  • We can write our own class definitions for them
  • Or use class definitions from the Java SE class library
• Java has arrays built into the language
• They may not seem very flexible:
  • They are fixed length, which you must choose when you create them
  • All data in an array must be of the same type (but see polymorphism later!)
  • All you can do to them is access the elements and find out the length
• But accessing elements of an array is efficient
• (In fact, underneath, Python lists are usually implemented using arrays in C)

Creating arrays

• Suppose you want an array that can hold 4 integers (my marathon times), referenced from a variable called times
• Declare the variable with its type:

  int[] times;

  A common error is to think that this creates the array!
• This is how to create the array:

  times = new int[4];

• Of course, you can instead do both in one statement:

  int[] times = new int[4];

• The elements of the array are initailized to the usual default values

Accessing arrays

• Arrays are indexed from 0
• Storing data in the array:

  times[0] = 154;
  times[1] = 176;
  times[2] = 154;
  times[3] = 135;

• To print all elements, you need a loop because the following won't print them:

  System.out.println(times);

• times.length gives you the length, e.g.

  System.out.println(times.length);

  Note this is a variable, not a method
• Accessing data stored in the array:

  System.out.println(times[1]);

• Q: So, why is array access so efficient?

Declaring, creating and initializing arrays

• Summary: This declares a variable, creates an array (with default initial values), references it from the variable, and then stores data in the array:

  int[] times = new int[4];
  times[0] = 154;
  times[1] = 176;
  times[2] = 154;
  times[3] = 135;

• There is a less cumbersome alternative:

  int[] times = {154, 176, 154, 135};

Arrays of objects

• Arrays can contain ints, doubles, booleans (primitive types)
• But they can also contain objects, e.g. Strings, Scanners, Randoms, Dogs (reference types)
• E.g. an array of Strings

  String suits = {"Clubs", "Diamonds", "Hearts", "Spades"};

• E.g. an array of Dogs

  Dog[] my_sled_team = new Dog[3];
  my_sled_team[0] = new Dog("Charles", 2, "Charlywawa");
  my_sled_team[1] = new Dog("Charlene", 7, "Charlywawa");
  my_sled_team[2] = new Dog("Charmaine", 4, "Charlywawa");

Class activity

1. On the next slide is a very basic class definition for playing card objects.
   Q: Can you think of a fancy word (from previous lectures) to describe objects created from this class definition?

   The subsequent slide contans a main method that creates 52 playing cards, puts them in an array, and prints them out again

2. But what we do in the lecture is better: we will write a class definition for decks of cards, whose interface can include:
   • public Deck()
   • public void shuffle()
   • public Card deal()
   The deal method will remove and return the last card in the array. We will write/discuss two ways to implement it:
   1. using a loop to copy the array of cards into a smaller array
   2. using the Arrays.copyOf class method
   (A later lecture will discuss a third, more efficient implementation)

   Q: By the way, is shuffle a getter or a setter? What about deal?

Card.java

class Card {

    int rank;
    String suit;
    
    public Card(int r, String s) {
        rank = r;
        suit = s;
    }
    
    public boolean higher(Card c) {
        return rank > c.rank;
    }
    
    public boolean lower(Card c) {
        return rank < c.rank;
    }
    
    public String toString() {
        return rank + " of " + suit;
    }
    
}

CardTester.java

class CardTester {

    public static void main(String[] args) {
        String[] suits = {"Clubs", "Diamonds", "Hearts", "Spades"};
        Card[] cards = new Card[52];
        int indexOfNextCard = 0;
        for (int i = 0; i < suits.length; i = i + 1) {
            for (int j = 1; j < 14; j = j + 1) {
                cards[indexOfNextCard] = new Card(j, suits[i]);
                indexOfNextCard = indexOfNextCard + 1;
                // cards[i * 13 + j - 1] = new Card(j, suits[i]);
            }
        }
        for (int k = 0; k < cards.length; k = k + 1) {
            System.out.println(cards[k]);
        }
    }
}