Java大数据结构与集合类.doc

《Java大数据结构与集合类.doc》由会员分享，可在线阅读，更多相关《Java大数据结构与集合类.doc（10页珍藏版）》请在三一办公上搜索。

1、wordJava collections A collection allows a group of objects to be treated as a single unit. Arbitrary objects can be stored, retrieved and manipulated as elements of these collections. Collections Framework presents a set of standard utility classes to manage such collections.1. It contains core int

2、erfaces which allow collections to be manipulated independent of their implementations. These interfaces define the mon functionality exhibited by collections and facilitate data exchange between collections.2. A small set of implementations that are concrete implementations of the core interfaces,

3、providing data structures that a program can use.3. An assortment of algorithms to perform various operations such as, sorting and searching. Collections framework is interface based, collections are implemented according to their interface type, rather than by implementation types. By using the int

4、erfaces whenever collections of objects need to be handled, interoperability and interchangeability are achieved. By convention each of the collection implementation classes provide a constructor to create a collection based on the elements in the Collection object passed as argument. By the same to

5、ken, Map implementations provide a constructor that accepts a Map argument. This allows the implementation of a collection (Collection/Map) to be changed. But Collections and Maps are not interchangeable. Interfaces and their implementationsCollection|_ Set (no dupes, null allowed based on implement

6、ation) HashSet|_ SortedSet (Ordered Set) TreeSet|_ List (ordered collection, dupes OK) Vector, ArrayList, LinkedListMap (key-value pairs, null allowed based on implementation) HashTable, HashMap | |_ SortedMap (Ordered Map) TreeMapInterfaceDescriptionCollectionA basic interface that defines the oper

7、ations that all the classes that maintain collections of objects typically implement.SetExtends Collection, sets that maintain unique elements. Set interface is defined in terms of the equals operationSortedSetExtends Set, maintain the elements in a sorted orderListExtends Collection, maintain eleme

8、nts in a sequential order, duplicates allowed.MapA basic interface that defines operations that classes that represent mappings of keys to values typically implementSortedMapExtends Map for maps that maintain their mappings in key order. Classes that implement the interfaces use different storage me

9、chanisms.1. ArraysIndexed access is faster. Makes insertion, deletion and growing the store more difficult.2. Linked ListSupports insertion, deletion and growing the store. But indexed access is slower.3. TreeSupports insertion, deletion and growing the store. Indexed access is slower. But searching

10、 is faster.4. HashingSupports insertion, deletion and growing the store. Indexed access is slower. But searching is faster.However, requires the use of unique keys for storing data elements.Data Structures InterfacesSetSortedSetListMapSortedMapHash TableHashSetHashMapHashTable Resizable ArrayArrayLi

11、stVectorBalanced TreeTreeSetTreeMapLinked ListLinkedListSome of the operations in the collection interfaces are optional, meaning that the implementing class may choose not to provide a proper implementation of such an operation. In such a case, an UnsupportedOperationException is thrown when that o

12、peration is invoked.InterfaceMethodsDescriptionCollectionBasic Operationsint size();boolean isEmpty();boolean contains(Object element);boolean add(Object element);boolean remove(Object element);Used to query a collection about its contents, and add/remove elements. The add() and remove() methods ret

13、urn true if the collection was modified as a result of the operation. The contains() method checks for membership.Bulk Operationsboolean containsAll(Collection c);boolean addAll(Collection c);boolean removeAll(Collection c);boolean retainAll(Collection c);void clear();Perform on a collection as a si

14、ngle unit.Operations are equivalent of set logic on arbitrary collections (not just sets). The addAll(), removeAll(), clear() and retainAll() methods are destructive. Array OperationsObject toArray();Object toArray(Object a);These methods bined with Arrays.asList() method provide the bridge between

15、arrays and collections. IteratorsIterator iterator();Iterator is an interface which has these methods.boolean hasNext();Object next();void remove();Returns an iterator, to iterate the collection. The remove() method is the only remended way to remove elements from a collection during the iteration.S

16、etNo new methods defined.The add() method returns false, if the element is already in the Set. No exceptions are thrown.ListElement Access by IndexObject get(int index);Object set(int index, Object element);void add(int index, Object element);Object remove(int index);boolean addAll(int index, Collec

17、tion c);First index is 0, last index is size() 1. An illegal index throws IndexOutOfBoundsException.Element Searchint indexOf(Object o);int lastIndexOf(Object o);If the element is not found, return 1.List IteratorsListIterator listIterator();ListIterator listIterator(int index);ListIterator extends

18、Iterator. It allows iteration in both directions.ListIterators additional methods:boolean hasPrevious();boolean previous();int nextIndex();int prviousIndex();void set(Object o);void add(Object o);Open Range ViewList subList(int fromIndex, int toIndex);Returns a range of the list from fromIndex (incl

19、usive) to toIndex (exclusive). Changes to view are reflected in the list and vice versa.MapBasic OperationsObject put(Object key, Object value);Object get(Object key);Object remove(Object key);boolean containsKey(Object key);boolean containsValue(Object value);int size();boolean isEmpty();The put me

20、thod replaces the old value, if the map previously contained a mapping for that key. The get method returns null, if the specified key couldnt be found in the map.Bulk Operationsvoid putAll(Map t);void clear();putAll() adds all the elements from the specified map.clear() removes all the elements fro

21、m the map.Collection ViewsSet keySet();Collection values();Set entrySet();Note that the values () method, returns a Collection, not a set. Reason is, multiple unique keys can map to the same value.Provide different views on a Map. Changes to views are reflected in the map and vice versa.Each pair is

22、 represented by an Object implementing Map.Entry interface.Object getKey();Object getValue();Object setValue(Object value);SortedSetRange View OperationsSortedSet headSet(Object toElement);SortedSet tailSet(Object fromElement);SortedSet subSet(Object fromElement, Object toElement);fromElement is inc

23、lusive, toElement is exclusive. The views present the elements sorted in the same order as the underlying sorted set.Min-Max PointsObject first();Object last();Return the first (lowest) and last (highest) elements.parator Accessparator parator();Returns the partor associated with this SortedSet, or

24、null if it uses natural ordering.SortedMapRange View OperationsSortedMap headMap(Object toKey);SortedSet tailMap(Object fromKey);SortedSet subMap(Object fromKey, Object toKey);SortedMap is sorted with keys.fromKey is inclusive, toKey is exclusive. The views present the elements sorted in the same or

25、der as the underlying sorted map.Min-Max PointsObject firstKey();Object lastKey();Return the first (lowest) and last (highest) keys.parator Accessparator parator();Returns the partor associated with this SortedMap, or null if it uses natural ordering. Sorting in SortedSets and SortedMaps can be impl

26、emented in two ways.1. Objects can specify their natural order by implementing parable interface. Many if the standard classes in Java API, such as wrapper classes, String, Date and File implement this interface. This interface defines a single method:int pareTo(Object o) returns negative, zero, pos

27、itive if the current object is less than, equal to or greater than the specified object.In this case a natural parator queries objects implementing parable about their natural order. Objects implementing this interface can be used: As elements in a sorted set. As keys in sorted map. In lists which c

28、an be sorted automatically by the Collections.sort() method.2. Objects can be sorted by specific parators, which implement parator interface. This interface defines the following method:int pare(Object o1, Object o2) returns negative, zero, positive if the first object is less than, equal to or grea

29、ter than the second object. It is remended that its implementation doesnt contradict the semantics of the equals() method. Specific parators can be specified in the constructors of SortedSets and SortedMaps. All classes provide a constructor to create an empty collection (corresponding to the class)

30、. HashSet, HashMap, HashTable can also be specified with an initial capacity as well as a load factor (the ratio of number of elements stored to its current capacity). Most of the time, default values provide acceptable performance. A Vector, like an array, contains items that can be accessed using

31、an integer index. However, the size of a Vector can grow and shrink as needed to acmodate adding and removing items after the Vector has been created. Vector (5,10) means initial capacity 5, additional allocation (capacity increment) by 10. Stack extends Vector and implements a LIFO stack. With the

32、usual push() and pop() methods, there is a peek() method to look at the object at the top of the stack without removing it from the stack. Dictionary is an obsolete class. HashTable extends dictionary. Elements are stored as key-value pairs. Vector and HashTable are the only classes that are thread-

33、safe. In Java 1.2, Iterator duplicates the functionality of Enumeration. New implementations should consider Iterator. Collections is a class, Collection is an interface. Collections class consists exclusively of static methods that operate on or return collections. Sorting and Searching algorithms

34、in the Collections class.static int binarySearch(List list, Object key)static void fill(List list, Object o)static void shuffle(List list, Object o)static void sort(List list) Factory methods to provide thread-safety and data immutability. These methods return synchronized (thread-safe) / immutable

35、collections from the specified collections.List safeList = Collections.synchronizedList(new LinkedList();SortedMap fixedMap = Collections.unmodifiableSortedMap(new SortedMap(); Constants to denote immutable empty collections in the Collections class: EMPTY_SET, EMPTY_LIST and EMPTY_MAP. Collections

36、class also has the following methods:MethodDescriptionpublic static Set singleton(Object o)Returns an immutable set containing only the specified objectpublic static List singletonList(Object o)Returns an immutable list containing only the specified objectpublic static Map singletonMap(Object key, O

37、bject value)Returns an immutable map containing only the specified key, value pair.public static List nCopies (int n, Object o)Returns an immutable list consisting of n copies of the specified object. The newly allocated data object is tiny (it contains a single reference to the data object). This m

38、ethod is useful in bination with the method to grow lists. The class Arrays, provides useful algorithms that operate on arrays. It also provides the static asList() method, which can be used to create List views of arrays. Changes to the List view affects the array and vice versa. The List size is t

39、he array size and cannot be modified. The asList() method in the Arrays class and the toArray() method in the Collection interface provide the bridge between arrays and collections.Set mySet = new HashSet(Arrays.asList(myArray);String strArray = (String) mySet.toArray(); All concrete implementations

40、 of the interfaces in java.util package are inherited from abstract implementations of the interfaces. For example, HashSet extends AbstractSet, which extends AbstractCollection. LinkedList extends AbstractList, which extends AbstractCollection. These abstract implementations already provide most of

41、 the heavy machinery by implementing relevant interfaces, so that customized implementations of collections can be easily implemented using them. BitSet class implements a vector of bits that grows as needed. Each ponent of the bit set has a boolean value. The bits of a BitSet are indexed by nonnega

42、tive integers. Individual indexed bits can be examined, set, or cleared. One BitSet may be used to modify the contents of another BitSet through logical AND, logical inclusive OR, and logical exclusive OR operations. By default, all bits in the set initially have the value false. A BitSet has a size

43、 of 64, when created without specifying any size. ConcurrentModificationException exception (extends RuntimeException) may be thrown by methods that have detected concurrent modification of a backing object when such modification is not permissible. For example, it is not permssible for one thread t

44、o modify a Collection while another thread is iterating over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator implementations (including those of all the collection implementations provided by the JDK) may choose to throw this exception if this beha

45、vior is detected. Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future. The big advantage of the collections over arrays is that the collections are growable, you do

46、not have to assign the size at creation time. The drawback of collections is that they only store objects and not primitives and this es with an inevitable performance overhead. Arrays do not directly support sorting, but this can be overe by using the static methods of the Collections. Here is an e

47、xample.import java.util.*;public class Sort public static void main(String argv) Sort s = new Sort(); Sort() String s = new String4; s0=z; s1=b; s2=c; s3=a; Arrays.sort(s); for(int i=0;i s.length;i+) System.out.println(si); The following example illustrates how you can add objects of different classes to a Vector. This contrasts with arrays where every element must be of the same type. The code then walks through each object printing to the standard output.