TIJ——Chapter Eleven:Holding Your Objects

Java Provides a number of ways to hold objects:

• An array associates numerical indexes to objects. It holds objects of a known type so that you don't have to cast the result when you're looking up an object. It can be multidimensional, and it can hold primitives. However, its size cannot be changed once you create it.
• A Collection holds signle elements, and a Map holds associated pairs. With Java generics, you specify the type of objec to be held in the containers, so you can't put the wrong type into a container and you don't have to cast elements when you fetch them out of a container. Both Collections and Maps automatically resize themselves as you add more elements. A container won't hold primitives, but autoboxing takes care of translating primitives back and forth to the wrapper types held in the container.
• Like an array, a List also associates numerical indexed to objects—thus, arrays and Lists are ordered containers.
• Use an ArrayList if you're doing a lot of random accesses, but a LinkedList if you will be doing a lot of insertions and removals in the middle of the list.
• The behavior of Queue and Stack is provided via the LinkedList.
• A Map is a way to associate not integral values, but objects with other objects. HashMap are designed for rapid access, whereas a TreeMap keeps its keys in sorted order, and thus is not as fast as a HashMap. A LinkedHashMap keeps its elements in insertion order, but provides rapid access with hashing.
• A set only accepts one of each type of object. HashSet provide maximally fast lookups, whereas TreeSet keep the elements in sorted order. LinkedHashSet keep elements in insertion order.
• There's no need to use the legacy classes Vector, Hashtable, and Stack in new code.

It's helpful to look at a simplified diagram of the Java containers(without the abstract classes or legacy components). This only includes the interfaces and classes that you will encounter on a regular basis.

图中，用粗黑线框包围的容器（HashMap、ArrayList、LinkedList、HashSet）是我们在开发过程中要频繁使用的；虚线框表示接口，实线框表示具体的实现类；空心箭头表示某一个类实现了所指向的接口，实心箭头表示一个类（或实现某个接口的类）能生成一个指向类的对象。

---

• 对于容器而言，使用泛型与不使用泛型的几个重要的区别是：当往容器中放元素的时候，如果使用泛型，那么对于类型不兼容的对象，会在编译期报错；而且从容器中取出元素的时候，使用泛型则不需要类型转换，而不使用泛型则必须进行类型转换。可以看出，使用泛型可以使我们的代码更精简、健壮，同时不必记忆放入容器中元素的类型。
• The Java container library takes the idea of "holding your object" and divides it into two distinct concepts, expressed as the basic interfaces of the library:Lists promise to maintain elements in a particular sequence. The List interface adds a number of methods to Collection that allow insertion and removal of elements in the middle of a List. There are two types of List:
  • Collection: a sequence of individual elements with one or more rules applied to them. A List must hold the elements in the way that they were inserted, a Set cannot have duplicate elements.
  • Map: a group of key-value object pairs, allowing you to look up a value using a key. An ArrayList allows you to look up an object using a number, so in a sense it associates number to objects. A map allows you to look up an object using another object. It's also called an associative array, because it associates objects with another objects, or a dictionary, because you look up a value object using a key object just like you look up a definition using a word. Maps are powerful programming tools.
• Lists promise to maintain elements in a particular sequence. The List Interface adds a number of methods to Collection that allow insertion and removal of elements in the middle of a List. There are two types of List:
• The basic ArrayList, which excels at randomly accessing elements, but is slower when inserting and removing elements in the middle of a List.
• The LinkedList, which provides optimal sequential access, with inexpensive insertions and deletions from the middle of the List. A LinkedList is relatively slow for random access, but it has a larger feature set than the ArrayList.
• The Java Iterator can move in only one direction, There's not much you can do with an Iterator except(With an Iterator, you don't need to worry about the number of elements in the container. That's taken care of for you by hasNext() and next()):
• Ask a Collection to hand you an Iterator using a method called iterator(). That Iterator will be ready to return the first element in the sequence.
• Get the next object in the sequence with next().
• See if there are more object in the sequence with hasNext().
• Remove the last element returned by the iterator with remove().
• HashSet uses hashing for speed. The Order maintained by a HashSet is different from a TreeSet or a LinkedHashSet, since each implementation has a different way of storing elements. TreeSet keeps elements sorted into a red-black tree data structure, whereas HashSet uses the hashing fuction. LinkedHashSet also uses hashing for lookup speed, but appears to maintain elements in insertion order using a linked list.
• A foreach statement works with an array or anything Iterable, but that doesn't mean that an array is automatically an Iterable, nor is there any autoboxing that takes place:

public class ArrayIsNotIterable
{
	static <T> void test(Iterable<T> ib)
	{
		for(T t : ib)
		{
			System.out.print(t + " ");
		}
	}

	public static void main(String[] args)
	{
		test(Arrays.asList(1, 2, 3));
		String[] strings = {"A", "B", "C"};

		// An array works in foreach, but it's not Iterable:
		// !test(strings);
		// You must explicitly convert it to Iterable:
		test(Arrays.asList(strings));
	}
}
/*
 Output:
 1 2 3 A B C
*/