CS 151 - Lecture 22

Cay S. Horstmann

Lab

• Work with a buddy
• One of you codes, the other types up the answers.
• One of you submits the code in the lab22 subdirectory of your personal repo, the other submits a file report.txt in the lab22 subdirectory of your personal repo.
• Put the name of the coding buddy into the report

Enumerating, Reading, and Writing Fields

• What fields does the java.lang.ArrayList class have? Which are not static? What are their types? (Hint: Modify one of the programs from the slides.)
• In your program, construct an ArrayList as

  ArrayList<String> myList = new ArrayList<>();
  myList.add("Hello");
  myList.add("World");

  Using reflection, list the contents of the size field. What is it, and how did you get it?
• Now use reflection to change size to have value 1000. How do you do that? (Hint: To avoid dealing with the pesky exceptions, add throws Exception to the main method.
• Then print myList. What happens?

Reflecting on Arrays

• When an array isn't long enough, you may want to increase its length. Can you use reflection to update the length field? Let's try. What are all fields of the class String[].class?
• Ok, that didn't work. array.length is just syntax, not an actual field. Instead, let's do this:

  public static Object[] grow(Object[] a, int newLength) throws Exception
  {
     Object[] newArray = new Object[newLength];
     for (int i = 0; i < Math.min(a.length, newLength); i++)
        newArray[i] = a[i];
     return newArray;
  }

  Try it out:

  String[] words = "Mary had a little lamb".split(" ");
  String[] moreWords = grow(words, 10);
  System.out.println(moreWords.length);
  System.out.println(moreWords[0].length());
  

  What happens?
• Ok, it didn't compile. What if you change String[] moreWords to Object[] moreWords ?
• Let's try it differently. Change moreWords back to a String[] and apply a cast (String[]). Does the program compile now?
• What happens when you run the program? Why?

Reflecting on Arrays

• Look into grow. It needs to make an array of the correct component type, not Object. The correct type is the component type of a. How can you find it? (Look into the API of java.lang.Class.)
• How do you make a new array of that type?
• Change new Object[newLength] to a call to (Object[]) Array.newInstance(...). See the API of java.lang.reflect.Array. Can you now call (String[]) grow(words)?
• Can you use grow to grow an array of int values? What happens if you try?
• Actually, it's possible to make grow work for primitive type arrays. In step 3, why didn't Array.newInstance return an Object[]? (Hint: What if the component type is int.class?)
• Drop the Object[] cast and declare newArray as an Object. What happens?
• We can no longer use newArray[i] = ... to set the new array value. Use Array.set instead. Does the program compile?
• You need to change the return type to Object. Double-check that you can still grow an array of strings.
• We still can't grow an int[] array because the parameter type is still Object[]. What happens if you change it to Object?
• Find out another way of getting the length, using reflection.
• Now can you grow an int array?