getClass (Returns the runtime class of this Object.)
hashCode (Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.)
equals (It is reflexive: for any non-null reference value x, x.equals(x) should return true.
It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
For any non-null reference value x, x.equals(null) should return false.)
clone (Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.) ( x.clone() != x x.clone().getClass() == x.getClass() x.clone().equals(x))
toString (Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object.)
wait (Wakes up a single thread that is waiting on this object's monitor. If any threads are waiting on this object, one of them is chosen to be awakened. The choice is arbitrary and occurs at the discretion of the implementation. A thread waits on an object's monitor by calling one of the wait methods.)
notify (Wakes up a single thread that is waiting on this object's monitor. If any threads are waiting on this object, one of them is chosen to be awakened.)
notifyAll (Wakes up all threads that are waiting on this object's monitor. A thread waits on an object's monitor by calling one of the wait methods.)
finalize (Called by the garbage collector on an object when garbage collection determines that there are no more references to the object. A subclass overrides the finalize method to dispose of system resources or to perform other cleanup.)
References
Strong
Weak
Soft
Phantom
Wildcard
Upper bounded <? extends Number> (erases to Number)
Lower bounded <? super Integer> (erases to Number)
Unbounded <?> (erases to Object)
Collections
ArrayList (ArrayList internally uses a dynamic array to store the elements. Manipulation with ArrayList is slow because it internally uses an array. If any element is removed from the array, all the bits are shifted in memory. ArrayList is better for storing and accessing data.)
LinkedList (Сложность выборки элемента всегда O(n). Сложность вставки элемента O(1), но только если у нас уже есть ссылка на элемент рядом с той позицией в которую мы хотим вставить) (LinkedList internally uses a doubly linked list to store the elements. Manipulation with LinkedList is faster than ArrayList because it uses a doubly linked list, so no bit shifting is required in memory. LinkedList is better for manipulating data.)
HashSet (сложность такая же как у HashMap) (This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time. This class permits the null element.)
LinkedHashSet (based on LinkedHashMap)
TreeSet (This implementation provides guaranteed log(n) time cost for the basic operations (add, remove and contains).) (based on TreeMap)
PriorityQueue (An unbounded priority queue based on a priority heap. The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time, depending on which constructor is used. A priority queue does not permit null elements.)
ArrayDeque (Most ArrayDeque operations run in amortized constant time. Exceptions include remove, removeFirstOccurrence, removeLastOccurrence, contains, iterator.remove(), and the bulk operations, all of which run in linear time.) (Resizable-array implementation of the Deque interface. Array deques have no capacity restrictions; they grow as necessary to support usage. They are not thread-safe; in the absence of external synchronization, they do not support concurrent access by multiple threads. Null elements are prohibited. This class is likely to be faster than Stack when used as a stack, and faster than LinkedList when used as a queue.)
HashMap (This implementation provides constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets.) (Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. (The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.) This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.)
LinkedHashMap (Like HashMap, it provides constant-time performance for the basic operations (add, contains and remove), assuming the hash function disperses elements properly among the buckets. Performance is likely to be just slightly below that of HashMap, due to the added expense of maintaining the linked list, with one exception: Iteration over the collection-views of a LinkedHashMap requires time proportional to the size of the map, regardless of its capacity. Iteration over a HashMap is likely to be more expensive, requiring time proportional to its capacity.) (This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order).)
TreeMap (Basic operations like search, get, put and remove take logarithmic time O(log n).) (TreeMap bases its internal working on the principles of red-black trees. The rule is that starting from the root, any element in the left branch of any node is always less than the element in the node itself. Those on the right are always greater.)
Concurrent collections
CopyOnWriteArrayList (A thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.) (same methods as ArrayList)
ConcurrentSkipListSet (based on ConcurrentSkipListSet)
CopyOnWriteArraySet (A Set that uses an internal CopyOnWriteArrayList for all of its operations. Thus, it shares the same basic properties:
It is best suited for applications in which set sizes generally stay small, read-only operations vastly outnumber mutative operations, and you need to prevent interference among threads during traversal. It is thread-safe. Mutative operations (add, set, remove, etc.) are expensive since they usually entail copying the entire underlying array. Iterators do not support the mutative remove operation.)
BlockingQueue Interface (BlockingQueue methods come in four forms, with different ways of handling operations that cannot be satisfied immediately, but may be satisfied at some point in the future: one throws an exception, the second returns a special value (either null or false, depending on the operation), the third blocks the current thread indefinitely until the operation can succeed, and the fourth blocks for only a given maximum time limit before giving up.)
LinkedBlockingQueue (An optionally-bounded blocking queue based on linked nodes. This queue orders elements FIFO (first-in-first-out). The head of the queue is that element that has been on the queue the longest time. The tail of the queue is that element that has been on the queue the shortest time. New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue. Linked queues typically have higher throughput than array-based queues but less predictable performance in most concurrent applications.)
ArrayBlockingQueue (This is a classic "bounded buffer", in which a fixed-sized array holds elements inserted by producers and extracted by consumers. Once created, the capacity cannot be changed. Attempts to put an element into a full queue will result in the operation blocking; attempts to take an element from an empty queue will similarly block.)
SynchronousQueue (A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa. A synchronous queue does not have any internal capacity, not even a capacity of one. You cannot peek at a synchronous queue because an element is only present when you try to remove it; you cannot insert an element (using any method) unless another thread is trying to remove it; you cannot iterate as there is nothing to iterate. The head of the queue is the element that the first queued inserting thread is trying to add to the queue; if there is no such queued thread then no element is available for removal and poll() will return null. For purposes of other Collection methods (for example contains), a SynchronousQueue acts as an empty collection. This queue does not permit null elements. Synchronous queues are similar to rendezvous channels used in CSP and Ada. They are well suited for handoff designs, in which an object running in one thread must sync up with an object running in another thread in order to hand it some information, event, or task.)
PriorityBlockingQueue (An unbounded blocking queue that uses the same ordering rules as class PriorityQueue and supplies blocking retrieval operations. )
DelayQueue (An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired. The head of the queue is that Delayed element whose delay expired furthest in the past. If no delay has expired there is no head and poll will return null. Expiration occurs when an element's getDelay(TimeUnit.NANOSECONDS) method returns a value less than or equal to zero. Even though unexpired elements cannot be removed using take or poll, they are otherwise treated as normal elements. For example, the size method returns the count of both expired and unexpired elements. This queue does not permit null elements.)
ConcurrentHashMap (A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as Hashtable, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access.)
ConcurrentSkipListMap (A scalable concurrent ConcurrentNavigableMap implementation. The map is sorted according to the natural ordering of its keys, or by a Comparator provided at map creation time, depending on which constructor is used.
This class implements a concurrent variant of SkipLists providing expected average log(n) time cost for the containsKey, get, put and remove operations and their variants. Insertion, removal, update, and access operations safely execute concurrently by multiple threads. Iterators are weakly consistent, returning elements reflecting the state of the map at some point at or since the creation of the iterator. They do not throw ConcurrentModificationException, and may proceed concurrently with other operations. Ascending key ordered views and their iterators are faster than descending ones.)
AtomicStampedReference (An AtomicStampedReference maintains an object reference along with an integer "stamp", that can be updated atomically.)
Locks
Semaphore (acquire(), release(), Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.)
ReentrantLock (A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with extended capabilities.) (lock, unlock, tryLock, getHoldCount, getOwner, getQueuedThreads, ...)
ReentrantReadWriteLock (A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing. The read lock may be held simultaneously by multiple reader threads, so long as there are no writers. The write lock is exclusive.) (readLock, writeLock, ...)
CountDownLatch (A CountDownLatch is initialized with a given count. This count is decremented by calls to the countDown() method. Threads waiting for this count to reach zero can call one of the await() methods. Calling await() blocks the thread until the count reaches zero.)
CyclicBarrier (A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. combineLatest)
Exchanger (A synchronization point at which threads can pair and swap elements within pairs. Each thread presents some object on entry to the exchange method, matches with a partner thread, and receives its partner's object on return.)
ForkJoinTask (Abstract base class for tasks that run within a ForkJoinPool. A ForkJoinTask is a thread-like entity that is much lighter weight than a normal thread. Huge numbers of tasks and subtasks may be hosted by a small number of actual threads in a ForkJoinPool, at the price of some usage limitations.)
Phaser (A reusable synchronization barrier, similar in functionality to CyclicBarrier and CountDownLatch but supporting more flexible usage.)
Executors
ThreadPoolExecutor (An ExecutorService that executes each submitted task using one of possibly several pooled threads, normally configured using Executors factory methods.)
ScheduledThreadPoolExecutor (A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.)
Serializable, Externalizable, Parcelable
Serializable (pass the responsibility of serialization to JVM and it’s default algorithm, it is marker interface and doesn't contain any method)
Externalizable (saving and restoring the object state through writeExternal(ObjectOutput), readExternal(ObjectInput))
Parcelable (Interface for classes whose instances can be written to and restored from a Parcel. Classes implementing the Parcelable interface must also have a non-null static field called CREATOR of a type that implements the Parcelable.Creator interface.)