Long before Java 2, Java provided ad hoc classes. For example: Dictionary, Vector, Stack, and Properties classes are used to store and manipulate object groups. Although these classes are very useful, they lack a core, unified theme. For this reason, the way of using the Vector class is very different from the way of using the Properties class.
The collection framework is designed to meet the following goals.
- The framework must be high-performance. The implementation of basic collections (dynamic arrays, linked lists, trees, hash tables) must also be efficient.
- The framework allows different types of collections to work in similar ways with a high degree of interoperability.
- The expansion and adaptation of a collection must be simple.
For this reason, the entire collection framework is designed around a set of standard interfaces. You can directly use the standard implementations of these interfaces, such as: LinkedList , HashSet , and TreeSet, etc. In addition, you can also implement your own collections through these interfaces.
As can be seen from the above collection framework diagram, the Java collection framework mainly includes two types of containers, one is a collection, which stores a collection of elements, and the other is a map, which stores key/value pair mappings. The Collection interface has 3 subtypes, List, Set, and Queue. Below are some abstract classes. Finally, there are concrete implementation classes. Commonly used are ArrayList, LinkedList, HashSet, LinkedHashSet, HashMap, LinkedHashMap, and so on.
The collection framework is a unified framework for representing and manipulating collections. All collection frames include the following:
- Interface: is an abstract data type representing a collection. For example, Collection, List, Set, Map, etc. The reason for defining multiple interfaces is to manipulate collection objects in different ways
- Implementation (class): It is the concrete realization of the collection interface. Essentially, they are reusable data structures, such as: ArrayList, LinkedList, HashSet, HashMap.
- Algorithm: Some useful calculations performed by methods in objects that implement the collection interface, such as searching and sorting. These algorithms are called polymorphism, because the same method can have different implementations on similar interfaces.
In addition to collections, the framework also defines several Map interfaces and classes. What is stored in the Map are key/value pairs. Although Maps are not collections, they are fully integrated in collections.
The collective framework system is shown in the figure
The Java collection framework provides a set of interfaces and classes with excellent performance and easy to use. The java collection framework is located in the java.util package, so when using the collection framework, you need to guide the package.
Collection interface
The collection framework defines some interfaces. This section provides an overview of each interface:
Serial number | Interface description |
---|---|
1 | Collection interface Collection is the most basic collection interface. A Collection represents a group of Objects, that is, the elements of the Collection. Java does not provide classes that directly inherit from Collection, but only provides sub-interfaces (such as List and set) that inherit from. The Collection interface stores a set of non-unique, unordered objects. |
2 | List interface The List interface is an ordered Collection. Using this interface, you can precisely control the position where each element is inserted, and you can access the elements in the List by index (the position of the element in the List, similar to the subscript of the array). The index of an element is 0, and the same elements are allowed. The List interface stores a set of non-unique, ordered (insertion order) objects. |
3 | SetSet has exactly the same interface as Collection, but the behavior is different. Set does not store duplicate elements. The Set interface stores a set of unique, unordered objects. |
4 | SortedSet inherits from Set to store an ordered collection. |
5 | The MapMap interface stores a set of key-value objects and provides a key (key) to value (value) mapping. |
6 | Map.Entry describes an element (key/value pair) in a Map. It is an internal class of Map. |
7 | SortedMap inherits from Map, keeping the Key in ascending order. |
8 | Enumeration This is a traditional interface and defined method through which you can enumerate (obtain one at a time) elements in a collection of objects. This traditional interface has been replaced by iterators. |
package com.design;
import java.util.*;
public class SetFramework {
public static void main (String[] args) {
/**
* List interface stores a group of not unique
* Ordered (insertion order) objects.
*/
List<String> list = new ArrayList<>();
list.add( "1" );
list.add( "2" );
list.add( "1" );
System.out.println(list.size());
System.out.println(list);
/**
* Set does not save duplicate elements.
* The Set interface stores a set of unique, unordered objects.
*/
Set<String> Setlist = new HashSet<>();
Setlist.add( "4000" );
Setlist.add( "1000" );
Setlist.add( "1000" );
Setlist.add( "2000" );
System.out.println(Setlist.size());
System.out.println(Setlist);
Iterator iterSet = Setlist.iterator();
while (iterSet.hasNext()) {
System.out.println(iterSet.next());
}
/**
* Inherited from Set to save an ordered collection.
*/
SortedSet <String> SortedSetlist = new TreeSet<>();
SortedSetlist.add( "4000" );
SortedSetlist.add( "1000" );
SortedSetlist.add( "1000" );
SortedSetlist.add( "2000" );
System.out.println(SortedSetlist.size());
System.out.println(SortedSetlist);
Iterator iterSortedSet = SortedSetlist.iterator();
while (iterSortedSet.hasNext()) {
System.out.println(iterSortedSet.next());
}
/**
* The Map interface stores a set of key-value objects
* Provide key (key) to value (value) mapping.
*/
Map map = new HashMap();
map.put( "22" , "2222" );
map.put( "55" , "5555" );
map.put( "88" , "8888" );
map.put( "33" , "3333" );
System.out.println(map);
/**
* Describe an element (key/value pair) in a Map
* Is an internal class of Map.
*/
}
}
Copy code
The difference between Set and List
- 1. The instance of the Set interface stores out-of-order, non-repetitive data. The List interface instance stores ordered and repeatable elements.
- 2. Set retrieval efficiency is low, deletion and insertion efficiency is high, insertion and deletion will not cause element position change <implementation class has HashSet, TreeSet> .
- 3. List is similar to array, which can grow dynamically, and automatically grow the length of List according to the length of the actual stored data. The efficiency of finding elements is high, and the efficiency of inserting and deleting is low, because it will cause the position of other elements to change. <Implementation classes are ArrayList, LinkedList, Vector> .
Collection implementation class (collection class)
Java provides a set of standard collection classes that implement the Collection interface. Some of them are concrete classes that can be used directly, while others are abstract classes that provide partial implementations of interfaces.
The standard collection classes are summarized in the following table:
Serial number | Class description |
---|---|
1 | AbstractCollection implements most of the collection interfaces. |
2 | AbstractList inherits from AbstractCollection and implements most of the List interface. |
3 | AbstractSequentialList inherits from AbstractList and provides chained access to data elements instead of random access. |
4 | LinkedList This class implements the List interface and allows null (empty) elements. It is mainly used to create a linked list data structure. This class has no synchronization method. If multiple threads access a List at the same time, you must implement the access synchronization yourself. The solution is to construct a synchronized List when creating the List. For example: ```html |
Listlist=Collections.synchronizedList(newLinkedList(...)); | |
```LinkedList search efficiency is low. | |
5 | ArrayList This class also implements the List interface, which implements a variable-size array, which provides better performance when randomly accessing and traversing elements. This class is also asynchronous and should not be used in multi-threaded situations. ArrayList grows by 50% of the current length, and the insertion and deletion efficiency is low. |
6 | AbstractSet inherits from AbstractCollection and implements most of the Set interface. |
7 | This class of HashSet implements the Set interface, does not allow duplicate elements, does not guarantee the order of elements in the set, and allows to contain elements with a value of null, but only one at most. |
8 | LinkedHashSet has a hash table and linked list implementation of the Set interface with predictable iteration order. |
9 | The TreeSet class implements the Set interface, which can implement sorting and other functions. |
10 | AbstractMap implements most of the Map interface. |
11 | HashMap HashMap is a hash table, which stores key-value pairs (key-value) mapping. This class implements the Map interface, stores data according to the HashCode value of the key, and has a fast access speed. At most, the key of one record is allowed to be null, and thread synchronization is not supported. |
12 | TreeMap inherits AbstractMap and uses a tree. |
13 | WeakHashMap inherits the AbstractMap class and uses a hash table with weak keys. |
14 | LinkedHashMap inherits from HashMap and uses the natural order of the elements to sort the elements. |
15 | IdentityHashMap inherits the AbstractMap class and uses reference equality when comparing documents. |
In the previous tutorial, the classes defined in the java.util package have been discussed, as shown below:
Serial number | Class description |
---|---|
1 | Vector This class is very similar to ArrayList, but this class is synchronous and can be used in multi-threaded situations. This class allows setting the default growth length, and the default expansion method is twice the original. |
2 | Stack Stack is a subclass of Vector, which implements a standard last-in first-out stack. |
3 | Dictionary The Dictionary class is an abstract class used to store key/value pairs, similar to the Map class. |
4 | Hashtable Hashtable is a subclass of the Dictionary class and is located in the java.util package. |
5 | Properties Properties inherits from Hashtable and represents a persistent set of properties. Each key and its corresponding value in the property list is a string. |
6 | BitSet A Bitset class creates a special type of array to store bit values. The size of the array in the BitSet will increase as needed. |
Ensemble algorithm
The collection framework defines several algorithms that can be used for collection and mapping. These algorithms are defined as static methods of the collection class.
Some methods can throw ClassCastException when trying to compare incompatible types. When trying to modify an unmodifiable collection, an UnsupportedOperationException is thrown.
The collection defines three static variables: EMPTY_SET, EMPTY_LIST, EMPTY_MAP. None of these variables can be changed.
Serial number | Algorithm Description |
---|---|
1 | Collection Algorithms Here is a list of all algorithm implementations. |
How to use iterators
Normally, you will want to traverse the elements in a collection. For example, show every element in the collection.
Generally, traversing arrays uses for loops or enhanced for. These two methods can also be used in the collection framework, but there is another method to traverse the collection framework by using iterators. It is an object that implements the Iterator interface or the ListIterator interface.
Iterators enable you to get or delete elements of the collection through loops. ListIterator inherits Iterator to allow bidirectional traversal of lists and modification of elements.
Serial number | Iterator method description |
---|---|
1 | Using Java Iterator Here are examples of all the methods provided by the Iterator and listIterator interfaces. |
Iterate over the ArrayList
Instance
import java.util.*;
public class Test {
public static void main (String[] args) {
List<String> list = new ArrayList<String>();
list.add( "Hello" );
list.add( "World" );
list.add( "HAHAHAHA" );
//The first traversal method uses foreach to traverse the List
for (String str: list) { //You can also rewrite for(int i=0;i<list.size();i++) This form
System.out.println(str);
}
//The second type of traversal is to traverse the linked list into array-related content
String[] strArray = new String[list.size()];
list.toArray(strArray);
for ( int i = 0 ;i<strArray.length;i++) //This can also be rewritten as foreach(String str:strArray)
{
System.out.println(strArray[i]);
}
//The third type of traversal uses an iterator for related traversal
Iterator<String> ite=list.iterator();
while (ite.hasNext()) //Judging that there is a value after the next element
{
System.out.println(ite.next());
}
}
}
Copy code
Analysis:
The three methods are used to traverse the ArrayList collection, the third method is to use the iterator method, this method does not have to worry about exceeding the length of the collection during the traversal process.
Traverse the Map
Instance
import java.util.*;
public class Test {
public static void main (String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put( "1" , "value1" );
map.put( "2" , "value2" );
map.put( "3" , "value3" );
//The first type: commonly used, secondary value
System.out.println( "traverse key and value through Map.keySet:" );
for (String key: map.keySet()) {
System.out.println( "key = " + key + " and value = " + map.get(key));
}
//The second
System.out.println( "Use iterator to traverse key and value through Map.entrySet:" );
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, String> entry = it.next();
System.out.println( "key= " + entry.getKey() + " and value= " + entry.getValue());
}
//The third type: recommended, especially when the capacity is large
System.out.println( "traverse key and value through Map.entrySet" );
for (Map.Entry<String, String> entry: map.entrySet()) {
System.out.println( "key = " + entry.getKey() + " and value = " + entry.getValue());
}
//The fourth
System.out.println( "traverse all values through Map.values(), but not key" );
for (String v: map.values()) {
System.out.println( "value= " + v);
}
}
}
Copy code
How to use the comparator
TreeSet and TreeMap store elements in sorted order. However, this is exactly what sort order is defined by the comparator.
This interface allows us to sort a collection in different ways.
Serial number | Comparator method description |
---|---|
1 | Use Java Comparator Here to list all the methods provided by the Comparator interface through examples |
summary
The Java collection framework provides programmers with pre-packaged data structures and algorithms to manipulate them.
A collection is an object that can hold references to other objects. The collection interface declares the operations that can be performed on each type of collection.
The classes and interfaces of the collection framework are in the java.util package.
After any object is added to the collection class, it is automatically converted to the Object type, so when it is taken out, a forced type conversion is required.