1. Preface

Since everything in JAVA is an object, holding objects is particularly important.

In JAVA, we can hold objects by creating a reference to them:

　　　　HoldingObject holding;

You can also create an array of objects to hold a specific set of objects:

　　　　HoldingObject holding  = new HoldingObject[10];

However, an object reference can only hold one object, and an object array can only hold a fixed number of objects of a certain type; however, we often encounter this situation, when writing a program, we do not know how many objects to create, or even the type of object to create, becauseIn this case, we need to be able to create any number of objects at any time and anywhere, which is not possible with the above two methods.The JAVA utility class library provides a fairly complete set of container classes to solve this problem. The basic types are List,Set,Queue,Map, which we call containers.

Classification of containers

As shown in the figure above, it is a simple container classification.As you can see, there are actually only two containers, Collection and Map, and Collection can be divided into List,Set, and Queue.They have two or three implementations, for example, ArrayList,LinkedList is the implementation of List, HashMap,TreeMap is the implementation of Map.In the figure above, commonly used containers are represented by thick black wireframes; point wireframes represent interfaces; solid wireframes represent specific classes; hollow arrows point lines indicate that a particular class implements an interface; solid arrows indicate that a class can generate objects of the class to which the arrows point.*

1)Collection:

Collection maintains a separate sequence of elements that obey one or more rules.Collection is an interface that represents a set of objects, also known as collections'elements. Some collections allow duplicate elements, while others do not.JDK does not provide any direct implementation of this interface; it provides more specific subinterface implementations (List, Set, Queue), which are often used to pass collections and operate on them where maximum universality is required.Here is a brief list of some of Collection's methods (screenshots from J2SE6_API):

a) List: elements must be saved in the order they are inserted

A List is an ordered collection, where users have precise control over where each element in the list is inserted. Users can access elements based on their integer index (position in the list) and search for elements in the list.The List interface adds a number of methods to the Collection, enabling elements to be inserted and removed from the middle of the List.Lists allow elements to be added, removed, or self-resized after they are created, which is exactly what they are worth: a modifiable sequence.There are two types of List implementations:

ArrayList: Random access to elements is faster, but inserting and removing elements is slower;

ArrayList has three constructions:

ArrayList();　　　　　　 // Construct an empty list with an initial capacity of 10

ArrayList(int x);　　　　// Construct an initial capacity of x Empty List

ArrayList(Collection<? extends E> c);　　// Construct a containing specification collection List of elements of the collection Iterators of

The following is a simple example of how ArrayList works:

package com.tongye.holding;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class HoldObject {    
    public static void main(String[] args){
        Random rand = new Random(47);
        Circle circle = new Circle();
        Square square = new Square();
        Triangle triangle = new Triangle();
        Rectangle rectangle = new Rectangle();
        
        // Establish List Example
        List<Integer> list1 = new ArrayList<Integer>();    // Create a Storage Only int List of type objects
        List<Shape> list2 = new ArrayList<Shape>();        // Create a Storage Only Shape List of type objects
        List list3 = new ArrayList(4);                    // Create a list with an initial capacity of 4 without specifying the type of storage        
        
        // To List list1 Add elements to
        for(int i = 0;i < 10;i++)
            list1.add(rand.nextInt(20));                // add(E e)Method that adds the specified element to the end of this list        
        for(Integer i : list1)                            // Be-all collection All available foreach Traverse
            System.out.print(i + " ");
        System.out.println("");
        
        // use subList Method intercept part list1 View
        List<Integer> list4 = list1.subList(3, 8);        // subList(int fromIndex,int toIndex)，Return to List
                                                        // from fromIndex(Include) to toIndex(Exclude) Partial views between
        for(Integer i : list4)                            
            System.out.print(i + " ");
        System.out.println("");
        
        // To List list2 Add elements to
        list2.add(circle);                                // Add an object to the list
        list2.add(square);
        list2.add(triangle);
        list2.add(1,rectangle);                            // add(int index,E e)Method to insert a specified element to a specified location in the list        
        for(Shape i : list2)                            // Be-all collection All available foreach Traverse
            System.out.println(i);
        System.out.println(list2.isEmpty());            // isEmpty()Method, checks if there are elements in the list, returns if there are no elements true
        System.out.println(list2.contains(circle));        // contains()Method checks to see if the list contains the specified element, or returns true
        System.out.println(list2.indexOf(square));        // indexOf()Method that returns the index number of an element in the list
        list2.get(1).showShape();                        
        list2.remove(rectangle);                        // remove(Object o)Method to delete the specified element that first appears in the list
        list2.get(1).showShape();
        list2.remove(1);
        list2.get(1).showShape();                        // remove(int index)Method to delete the element in the list at the specified index
        
        // towards list3 Add elements to
        list3.add(100);
        list3.add("Add a string to the list");
        list3.add(rectangle);
        list3.add(1.048596);
        list3.add("Automatic Capacity Growth");
        for(int i = 0;i < 5;i++)
            System.out.println(list3.get(i));
    }
}

class Shape{
    public void showShape(){
        System.out.println("Shape class");
    }
}

class Circle extends Shape{
    public void showShape(){
        System.out.println("Circle class");
    }
}

class Square extends Shape{
    public void showShape(){
        System.out.println("Square class");
    }
}

class Triangle extends Shape{
    public void showShape(){
        System.out.println("Triangle class");
    }
}

class Rectangle extends Shape{
    public void showShape(){
        System.out.println("Rectangle class");
    }
}