set

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:

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:

In the previous tutorial, the classes defined in the java.util package have been discussed, as shown below:

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.

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.

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.

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.