Java Note-collection interface for Java Note-collection

preface

The body of the

A collection of

The Collection interface

The Collection interface has three subinterfaces:

• List: Ordered and elements are repeatable
• Set: Unordered union elements are not repeatable
• Queue: A first-in, first-out linear data structure in which only the first element of the Queue is observed.

The List interface

Common implementation classes for List are:

• ArrayList: The underlying implementation is through arrays, high query performance, slow insert and delete. The advantage of its traversal lies in its continuity in memory.
• LinkedList: Through bidirectional linked list implementation, query performance is slightly lower, but insert and delete performance is high, except implementationListInterface, but also implementedQueueInterface.
• Vector: Data structure andArrayListSimilarly, throughsynchronizedTo achieve thread safety, andStackThe stack is implementedVectorOf the interface.

Key points:

1. A thread-safe way to implement ArrayList

• usesynchronizedOr the lock
• Direct use ofVector, but JDK1.2 is officially recommended to deprecate
• useCollections.synchronizedList(list)To implement the

2. Construction and expansion of ArrayList

• ArrayList arrayList =new ArrayList(), default generates an array of capacity 0, onlyadd()Element, the default initial capacity of 10 is allocated.
• If all 10 capacities are full, the capacity is increased by 50% to 15.

Therefore, when accessing an array of known size, the initial capacity should be set as far as possible to avoid triggering continuous expansion operations.

3. Why does ArrayList insert and delete perform poorly? Insert and delete both involve copying arrays (i.e. data migration), and the earlier the operation, the longer the array that needs to be copied.

Why was Vector deprecated? The use of synchronized in all Vector methods greatly affects the performance of the entire data operation. In fact, Hashtable has a similar problem. So ArrayList became a Vector replacement after jdk1.2.

The Set interface

Common implementation classes for Set are:

• HashSet: it is based onHashMapThe default constructor implemented is to build an initial capacity of 16 with a load factor of 0.75HashMap. Through rewritingequals(Object obj)Methods andhashCode()To achieve de-weighting.
• TreeSet: The data structure is a red-black tree, which is de-weighted by a comparator. It is ordered in the sense that it is sorted by comparator elements.
• LinkedHashSet:LinkedHashSetThe underlying useLinkedHashMapTo save all the elements, by rewritingequals(Object obj)Methods andhashCode()To achieve de-weighting. Its orderliness means that the order of storage is the same as the order of retrieval.

The Queue interface

There are three main implementation classes for Queue:

• Non-blocking implementation classes, such as:ConcurrentLinkedQueue, the use ofCASThe operation implements an unbounded thread-safe queue, avoiding the performance impact of locking.
• Blocking implementation classes, such as:ArrayBlockingQueue(bounded),LinkedBlockingQueue(unbounded), which blocks when the queue is full and new elements are added to the thread, stopping the addition and waiting for the queue to be empty.
• deque:DueueElements can be added and removed at both ends.

Blocking queues implement blocking synchronization in a simple way, using the condition blocking control of a LOCK lock.

Common methods of Queue:

• Add () : Adds a new element to the end of the queue.
• offer(): Added an element at the end of the queue, returned when it was fullfalse.
• Remove () : deletes the first element of the queue, and the element is a null-throw exception.
• poll(): Deletes the first element of the queue, and returns if the element is emptynullIf it is not empty, the element is obtained.
• Element () : Queries the first element of the queue, with a null-cast exception.
• peek(): Queries the first element of the queuenull.

ConcurrentLinkedQueue

ConcurrentLinkedQueue is a thread-safe queue for atomic operations provided under java.util.Concurrent. Both ConcurrentLinkedQueue and LinkedBlockingQueue are thread-safe, the difference being:

• LinkedBlockingQueue: Mostly used for task queues where a consumer consumes different messages from different producers.
• ConcurrentLinkedQueue: Used mostly for message queues where a producer provides the same message to different consumers.

ArrayBlockingQueue

ArrayBlockingQueue Specifies the bounded blocking queue that the thread pool configures.

• ArrayListNot good for queues, but arrays are good for queues,ArrayBlockingQueueIs a ring queue, which is a fixed-length, thread-safe blocking queue, internally implemented with a fixed-length array. It is thread safe and obstructive both throughReentrantLockTo achieve.
• ArrayBlockingQueueThe process of dequeuing and enqueuing can be abstractly regarded as a vernier caliper of fixed length in memory. So when an exit occurs, the team leader is constantly changing, not alwaysitems[0], the first time is 0, and the second exit is 1, so there is no operation involving data migration.

    private final E[] items;// The underlying data structure
    private int takeIndex;// Index used for the next take/poll/remove
    private int putIndex;// Index used for the next put/offer/add
    private int count;// The number of elements in the queue

    /** Main lock guarding all access */
    private final ReentrantLock lock;/ / lock
    /** Condition for waiting takes */
    private final Condition notEmpty;// Wait for the conditions to exit the queue
    /** Condition for waiting puts */
    private final Condition notFull;// Waiting for the conditions to join the team
Copy the code

other

//array converts to list
int[] arr = {1.3.4.6.6};
List list =Arrays.asList(arr);

//list is converted to Array
String arratb[] =(String [])list.toArray();
Copy the code