Generic Array Lists Core Java

In many programming languages—in particular, in C—you have to fix the sizes of all arrays at compile time. Programmers hate this because it forces them into uncomfortable trade-offs. How many employees will be in a department? Surely no more than 100. What if there is a humongous department with 150 employees? Do we want to waste 90 entries for every department with just 10 employees?

In Java, the situation is much better. You can set the size of an array at runtime.

Of course, this code does not completely solve the problem of dynamically modifying arrays at runtime. Once you set the array size, you cannot change it easily. Instead, the easiest way in Java to deal with this common situation is to use another Java class, called ArrayList. The ArrayList class is similar to an array, but it automatically adjusts its capacity as you add and remove elements, without your needing to write any code.

As of Java SE 5.0, ArrayList is a generic class with a type parameter. To specify the type of the element objects that the array list holds, you append a class name enclosed in angle brackets, such as ArrayList <Employee>. You will see in Chapter 13 how to define your own generic class, but you don’t need to know any of those technicalities to use the ArrayList type.

Here we declare and construct an array list that holds Employee objects:

NOTE: Before Java SE 5.0, there were no generic classes. Instead, there was a single ArrayList class, a “one size fits all” collection that holds elements of type Object. If you must use an older version of Java, simply drop all <...> suffixes. You can still use ArrayList without a <...> suffix in Java SE 5.0 and beyond. It is considered a “raw” type, with the type parameter erased.

NOTE: In even older versions of the Java programming language, programmers used theVector class for dynamic arrays. However, the ArrayList class is more efficient, and there is no longer any good reason to use the Vector class.

You use the add method to add new elements to an array list. For example, here is how you populate an array list with employee objects:

The array list manages an internal array of object references. Eventually, that array will run out of space. This is where array lists work their magic: If you call add and the internal array is full, the array list automatically creates a bigger array and copies all the objects from the smaller to the bigger array.

If you already know, or have a good guess, how many elements you want to store, then call the ensureCapacity method before filling the array list:

That call allocates an internal array of 100 objects. Then, the first 100 calls to add do not involve any costly reallocation. You can also pass an initial capacity to the ArrayList constructor:

CAUTION: Allocating an array list as new ArrayList<Employee>(100) // capacity is 100 is not the same as allocating a new array as

There is an important distinction between the capacity of an array list and the size of an array. If you allocate an array with 100 entries, then the array has 100 slots, ready for use.

An array list with a capacity of 100 elements has the potential of holding 100 elements (and, in fact, more than 100, at the cost of additional reallocations); but at the beginning, even after its initial construction, an array list holds no elements at all.

The size method returns the actual number of elements in the array list. For example,

returns the current number of elements in the staff array list. This is the equivalent of

a.length for an array a.

Once you are reasonably sure that the array list is at its permanent size, you can call the trimToSize method. This method adjusts the size of the memory block to use exactly as much storage space as is required to hold the current number of elements. The garbage collector will reclaim any excess memory.

Once you trim the size of an array list, adding new elements will move the block again, which takes time. You should only use trimToSize when you are sure you won’t add any more elements to the array list.

C++ NOTE: The ArrayList class is similar to the C++ vector template. Both ArrayList and vector are ge eric types. But the C++ vector template overloads the [] operator for convenient element access. Because Java does not have operator over loading, it must use explicit method calls instead. Moreover, C++ vectors are copied by value. If a and b are two vectors, then the assignment a = b makes a into a new vector with the same length as b, and all elements are copied from b to a. The same assignment in Java makes both a and b refer to the same array list.

  • ArrayList<T>()
    constructs an empty array list.
  • ArrayList<T>(int initialCapacity)
    constructs an empty array list with the specified capacity.
Parameters: initialCapacity the initial storage capacity of the array list boolean add(T obj)

appends an element at the end of the array list. Always returns true.

Parameters: obj the element to be added int size()

returns the number of elements currently stored in the array list. (Of course, this isnever larger than the array list’s capacity.)

  • void ensureCapacity(int capacity)
    ensures that the array list has the capacity to store the given number of elements
  • without reallocating its internal storage array.

    Parameters: capacity the desired storage capacity

  • void trimToSize()
    reduces the storage capacity of the array list to its current size.

Accessing Array List Elements

Unfortunately, nothing comes for free. The automatic growth convenience that array lists give requires a more complicated syntax for accessing the elements. The reason isthat the ArrayList class is not a part of the Java programming language; it is just a utility class programmed by someone and supplied in the standard library.

Instead of using the pleasant [] syntax to access or change the element of an array, youuse the get and set methods.

For example, to set the ith element, you use

for an array a. (As with arrays, the index values are zero-based.)

CAUTION: Do not call list.set(i, x) until the size of the array list is larger than i. For example,the following code is wrong:

Use the add method instead of set to fill up an array, and use set only to replace a previouslyadded element.

To get an array list element, use This is equivalent to

NOTE: Before Java SE 5.0, there were no generic classes, and the get method of the rawArrayList class had no choice but to return an Object. Consequently, callers of get had tocast the returned value to the desired type:

The raw ArrayList is also a bit dangerous. Its add and set methods accept objects of anytype. A call

compiles without so much as a warning, and you run into grief only when you retrieve the object and try to cast it. If you use an Array List< Employee> instead, the compiler will detectthis error.

You can some times get the best of both worlds —flexible growth and convenient element access —with the following trick. First, make an array list and add all the elements:

When you are done, use the toArray method to copy the elements into an array:

Sometimes, you need to add elements in the middle of an array list. Use the add methodwith an index parameter:

The elements at locations n and above are shifted up to make room for the new entry. Ifthe new size of the array list after the insertion exceeds the capacity, then the array listreallocates its storage array.

Similarly, you can remove an element from the middle of an array list:

The elements located above it are copied down, and the size of the array is reduced byone.

Inserting and removing elements is not terribly efficient. It is probably not worth worryingabout for small array lists. But if you store many elements and frequently insert andremove in the middle of a collection, consider using a linked list instead.

As of Java SE 5.0, you can use the “for each” loop to traverse the contents of an array list:

for (Employee e : staff)do something with e This loop has the same effect as

Listing below is a modification of the EmployeeTest program. The Employee[] arrayis replaced by an ArrayList<Employee>. Note the following changes:

  • You don’t have to specify the array size.
  • You use add to add as many elements as you like.
  • You use size() instead of length to count the number of elements.
  • You use a.get(i) instead of a[i] to access an element.

java.util.ArrayList<T> 1.2

puts a value in the array list at the specified index, overwriting the previous contents.

gets the value stored at a specified index.

shifts up elements to insert an element.

removes an element and shifts down all elements above it. The removed elementis returned.

Compatibility between Typed and Raw Array Lists

When you write new code with Java SE 5.0 and beyond, you should use type parameters,such as ArrayList<Employee>, for array lists. However, you may need to interoperatewith existing code that uses the raw ArrayList type.

Suppose that you have the following legacy class:

You can pass a typed array list to the update method without any casts.

The staff object is simply passed to the update method.

CAUTION: Even though you get no error or warning from the compiler, this call is not completelysafe. The update method might add elements into the array list that are not of typeEmployee. When these elements are retrieved, an exception occurs. This sounds scary, but ifyou think about it, the behavior is simply as it was before Java SE 5.0. The integrity of thevirtual machine is never jeopardized. In this situation, you do not lose security, but you alsodo not benefit from the compile-time checks.

Conversely, when you assign a raw ArrayList to a typed one, you get a warning.

NOTE:To see the text of the warning, compile with the option -Xlint: unchecked.

Using a cast does not make the warning go away.

Instead, you get a different warning, telling you that the cast is misleading.

This is the onsequence of a somewhat unfortunate limitation of generic types in Java.For compatibility, the compiler translates all typed array lists into raw ArrayList objectsafter checking that the type rules were not violated. In a running program, all array listsare the same—there are no type parameters in the virtual machine. Thus, the casts(ArrayList) and (ArrayList<Employee>) carry out identical runtime checks.

There isn’t much you can do about that situation. When you interact with legacy code,study the compiler warnings and satisfy yourself that the warnings are not serious.



Face Book Twitter Google Plus Instagram Youtube Linkedin Myspace Pinterest Soundcloud Wikipedia

All rights reserved © 2018 Wisdom IT Services India Pvt. Ltd DMCA.com Protection Status

Core Java Topics