JAVA Common Collection Interface list, set, map summary

The list, set, and map interfaces are frequently used in Java to summarize the following

Their inheritance and implementation relationships are as follows:

Collection
├list
│├linkedlist
│├arraylist
│└vector
│└stack
└set
Map
├hashtable
├hashmap
└weakhashmap

An excerpt from an article, reproduced http://blog.csdn.net/dotnetdesigner/archive/2007/11/08/1874605.aspx

The Collection interface collection is the most basic collection interface, and a collection represents a set of object, the collection element (Elements). Some collection allow the same elements while others do not. Some can sort and others can't.　　The Java SDK does not provide classes that inherit directly from collection, and the Java SDK provides classes that inherit from collection, such as list and set. All classes that implement the collection interface must provide two standard constructors: a parameterless constructor is used to create an empty collection, and a constructor with a collection parameter is used to create a new collection. This new collection has the same elements as the incoming collection.　　The latter constructor allows the user to copy a collection. How do I traverse every element in the collection? Regardless of the actual type of collection, it supports a iterator () method that returns an iteration that uses the iteration to access each element of the collection one at a time. Typical usage is as follows: Iterator it= Collection.iterator ();//get an iteration child 　　　　  while(It.hasnext ()) {Object obj= It.next ();//get the next elementThe two interfaces that are derived from the collection interface are list and set. The list interface list is an ordered collection, using this interface to precisely control where each element is inserted. The user is able to access the elements in the list using an index (where the element is positioned in the list, similar to an array subscript), similar to an array of java.　　Unlike the set mentioned below, the list allows the same elements. In addition to the iterator () method, which has the collection interface prerequisites, the list also provides a listiterator () method that returns a Listiterator interface, compared to the standard iterator interface.　　Listiterator has a number of add () methods that allow you to add, delete, set elements, and traverse forward or backward. The common classes that implement the list interface are Linkedlist,arraylist,vector and stacks. The LinkedList class LinkedList implements the list interface, allowing null elements. Additionally LinkedList provides an additional Get,remove,insert method at the first or the tail of the LinkedList.　　These operations make the LinkedList available as a stack (stack), queue, or two-way queue (deque). Note LinkedList does not have a synchronization method. If multiple threads access a list at the same time, you must implement access synchronization yourself. One workaround is to construct a synchronized list:list list when the list is created= Collections.synchronizedlist (NewLinkedList (...)); The ArrayList class ArrayList implements a variable-sized array. It allows all elements, including null. ArrayList is not synchronized. Size,isempty,get,set method run time is constant. But the Add method cost is the allocated constant, and adding n elements requires an O (n) time.　　Other methods run at a linear time. Each ArrayList instance has a capacity (capacity), which is the size of the array used to store the elements. This capacity automatically increases as new elements are added, but the growth algorithm is not defined.　　When you need to insert a large number of elements, you can call the Ensurecapacity method before inserting to increase the capacity of the ArrayList to improve insertion efficiency. Like LinkedList, ArrayList is also unsynchronized (unsynchronized). Vector vectors are very similar to ArrayList, but vectors are synchronous. The iterator created by the vector, although the same interface as the iterator created by ArrayList, but because the vector is synchronous, when a iterator is created and is being used, another thread changes the state of the vector (for example, Some elements have been added or removed, Concurrentmodificationexception will be thrown when the iterator method is called, so the exception must be caught. The Stack class stack inherits from the vector and implements a last-in-first-out stack. The stack provides 5 additional ways to make the vector available as a stack. The basic push and pop methods, and the Peek method to get the stack top element, the empty method tests if the stack is empty, and the search method detects the position of an element on the stack. Stack has just been created as an empty stack. Set interface set is a collection that contains no duplicate elements, i.e. any two elements E1 and E2 have E1.equals (E2)=false, the set has a maximum of one null element.　　Obviously, the constructor of a set has a constraint that the passed-in collection parameter cannot contain duplicate elements. Note: Variable objects (Mutable object) must be handled with care. If a mutable element in a set changes its state to cause object.equals (Object)=true will cause some problems. Map interface Note that map does not inherit the collection interface, and map provides a key-to-value mapping. A map cannot contain the same key, and each key can only map one value. The map interface provides a view of 3 collections, and the contents of the map can be treated as a set of key sets, a set of value sets, or a set of key-The value mapping. The Hashtable class Hashtable inherits the map interface and implements a keyThe-value mapped hash table. Any non-null (non-NULL) object can be either key or value. Add data using put (key, value), take out the data using get (key), the time overhead for these two basic operations is constant. The Hashtable adjusts performance through the initial capacity and load factor two parameters. Typically the default load factor0. 75 a better balance of time and space is achieved. Increasing the load factor can save space but the corresponding lookup time will increase, which will affect operations like get and put. A simple example of using Hashtable is 1,2, 3 put in Hashtable, their key is "one", "two", "three": Hashtable numbers=NewHashtable (); Numbers.put ("One",NewInteger (1)); Numbers.put ("Both",NewInteger (2)); Numbers.put ("Three",NewInteger (3)); To take out a number, such as 2, with the corresponding Key:integer n=(Integer) numbers.get ("both"); System.out.println ("The= "+N); Because an object that is a key will determine the position of its corresponding value by calculating its hash function, any object that is a key must implement the Hashcode and Equals methods. The hashcode and Equals methods inherit from the root class object, and if you use a custom class as key, be quite careful, as defined by the hash function, if two objects are the same, that is, Obj1.equals (OBJ2)=true, their hashcode must be the same, but if two objects are different, their hashcode are not necessarily different, and if the hashcode of two different objects is the same, this phenomenon is called a conflict, which causes the time overhead of manipulating the hash table to increase.　　So try to define a good hashcode () method, which can speed up the operation of the hash table.　　If the same object has different hashcode, the operation of the hash table will have unexpected results (expecting the Get method to return null), to avoid this problem, you need to keep in mind one: to replicate both the Equals method and the Hashcode method, rather than write only one of them. The Hashtable is synchronous. The HashMap class HashMap is similar to Hashtable, except that HashMap is non-synchronous and allows NULL, which is null value and null key. , but when HashMap is treated as collection (the values () method can return collection), its iteration sub-operation time overhead is proportional to the capacity of HashMap. Therefore, if the performance of the iterative operation is quite important, do not set the initialization capacity of the hashmap too high or load factor too low. The Weakhashmap class Weakhashmap is an improved hashmap, which implements a "weak reference" to key, which can be recycled by GC if a key is no longer referenced externally.　　Summary if involved in stacks, queues and other operations, should consider using the list, for the need to quickly insert, delete elements, should use LinkedList, if you need to quickly randomly access elements, you should use ArrayList.　　If the program is in a single-threaded environment, or if access is done only in one thread, it is more efficient to consider non-synchronous classes, and if multiple threads may operate on a class at the same time, the synchronized classes should be used.　　Pay special attention to the operation of the hash table, and the object as key should correctly replicate the Equals and Hashcode methods. Try to return the interface rather than the actual type, such as returning a list instead of ArrayList, so that if you need to change ArrayList to LinkedList later, the client code does not have to be changed. This is for abstract programming. 

Next, we deal with several common ArrayList, HashMap and TreeSet.

JAVA Common Collection Interface list, set, map summary