Also note that the collections library was carefully designed to include several implementations of
each of the three basic collection types. These implementations have specific performance
characteristics which are described
in the guide.

Equivalent to x.hashCode except for boxed numeric types and null.
For numerics, it returns a hash value which is consistent
with value equality: if two value type instances compare
as true, then ## will produce the same hash value for each
of them.
For null returns a hashcode where null.hashCode throws a
NullPointerException.

Note that the success of a cast at runtime is modulo Scala's erasure semantics.
Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at
runtime, while the expression List(1).asInstanceOf[List[String]] will not.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the requested type.

Tests whether the argument (that) is a reference to the receiver object (this).

Tests whether the argument (that) is a reference to the receiver object (this).

The eq method implements an equivalence relation on
non-null instances of AnyRef, and has three additional properties:

It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of
x.eq(y) consistently returns true or consistently returns false.

For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.

null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they
should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

returns

true if the argument is a reference to the receiver object; false otherwise.

Note that the result of the test is modulo Scala's erasure semantics.
Therefore the expression 1.isInstanceOf[String] will return false, while the
expression List(1).isInstanceOf[List[String]] will return true.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the specified type.

returns

true if the receiver object is an instance of erasure of type T0; false otherwise.

The returned Java ConcurrentMap is backed by the provided Scala concurrent.Map and any
side-effects of using it via the Java interface will be visible via the Scala interface and
vice versa.

If the Scala concurrent.Map was previously obtained from an implicit or explicit call of
JavaConverters.mapAsScalaConcurrentMap(java.util.concurrent.ConcurrentMap) then the
original Java ConcurrentMap will be returned.

The returned Scala ConcurrentMap is backed by the provided Java ConcurrentMap and any
side-effects of using it via the Scala interface will be visible via the Java interface and
vice versa.

If the Java ConcurrentMap was previously obtained from an implicit or explicit call of
JavaConverters.mapAsJavaConcurrentMap(scala.collection.mutable.ConcurrentMap)
then the original Scala ConcurrentMap will be returned.

The returned Scala Map is backed by the provided Java Map and any side-effects of using it
via the Scala interface will be visible via the Java interface and vice versa.

If the Java Map was previously obtained from an implicit or explicit call of
JavaConverters.mutableMapAsJavaMap(scala.collection.mutable.Map) then the original Scala
Map will be returned.

If the wrapped map is synchronized (e.g. from java.util.Collections.synchronizedMap), it is
your responsibility to wrap all non-atomic operations with underlying.synchronized.
This includes get, as java.util.Map's API does not allow for an atomic get when null
values may be present.

Creates a String representation of this object. The default
representation is platform dependent. On the java platform it
is the concatenation of the class name, "@", and the object's
hashcode in hexadecimal.