Docs4dev
Docs
scala / 3.2 / scala / anyref.html

Class AnyRef.AnyRef

class AnyRef

Class AnyRef is the root class of all reference types. All types except the value types descend from this class.

Known subtypes
350 types
trait () => R
class FromJavaBooleanSupplier
class FromJavaDoubleSupplier
class FromJavaIntSupplier
class FromJavaLongSupplier
class FromJavaSupplier[T]
trait Reference[T]
trait ReferenceWrapper[T]
class PhantomReference[T]
class SoftReference[T]
class WeakReference[T]
class AbstractFunction0[R]
trait JFunction0$mcB$sp
trait JFunction0$mcC$sp
trait JFunction0$mcD$sp
trait JFunction0$mcF$sp
trait JFunction0$mcI$sp
trait JFunction0$mcJ$sp
trait JFunction0$mcS$sp
trait JFunction0$mcV$sp
trait JFunction0$mcZ$sp
trait T1 => R
class From <:< To
class From =:= To
class Conversion[T, U]
trait PartialFunction[A, B]
trait MapOps[K, V, CC, C]
trait Map[K, V]
class AbstractMap[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
class AbstractMap[K, V]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
class SystemProperties
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SeqMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMap[K, V]
trait SortedMap[K, V]
trait Map[K, V]
trait Map[K, V]
trait Map[K, V]
trait MultiMap[K, V]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapView[K, V]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait MapOps[K, V, CC, C]
trait MapOps[K, V, CC, C]
trait Seq[A]
class AbstractSeq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil.type
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty.type
class Vector[A]
class WrappedString
class AbstractSeq[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class StringBuilder
trait IndexedSeq[A]
trait IndexedSeq[A]
trait IndexedSeq[T]
trait IndexedBuffer[A]
trait LinearSeq[A]
trait LinearSeq[A]
trait Seq[A]
trait Seq[A]
trait Buffer[A]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
class DoubleAccumulator
class IntAccumulator
class LongAccumulator
class AbstractPartialFunction[T1, R]
trait SetOps[A, CC, C]
trait Set[A]
class AbstractSet[A]
class AbstractSet[A]
class ValueSet
class ImmutableKeySet
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class ImmutableKeySortedSet
class TreeSet[A]
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
trait BitSet
trait SortedSet[A]
trait SortedSet[A]
trait Set[A]
trait Set[A]
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait SetOps[A, CC, C]
trait SetOps[A, CC, C]
class FromJavaConsumer[T]
class FromJavaDoubleConsumer
class FromJavaDoubleFunction[R]
class FromJavaDoublePredicate
class FromJavaDoubleToIntFunction
class FromJavaDoubleToLongFunction
class FromJavaDoubleUnaryOperator
class FromJavaFunction[T, R]
class FromJavaIntConsumer
class FromJavaIntFunction[R]
class FromJavaIntPredicate
class FromJavaIntToDoubleFunction
class FromJavaIntToLongFunction
class FromJavaIntUnaryOperator
class FromJavaLongConsumer
class FromJavaLongFunction[R]
class FromJavaLongPredicate
class FromJavaLongToDoubleFunction
class FromJavaLongToIntFunction
class FromJavaLongUnaryOperator
class FromJavaPredicate[T]
class FromJavaToDoubleFunction[T]
class FromJavaToIntFunction[T]
class FromJavaToLongFunction[T]
class FromJavaUnaryOperator[T]
class AbstractFunction1[T1, R]
trait JFunction1$mcDD$sp
trait JFunction1$mcDF$sp
trait JFunction1$mcDI$sp
trait JFunction1$mcDJ$sp
trait JFunction1$mcFD$sp
trait JFunction1$mcFF$sp
trait JFunction1$mcFI$sp
trait JFunction1$mcFJ$sp
trait JFunction1$mcID$sp
trait JFunction1$mcIF$sp
trait JFunction1$mcII$sp
trait JFunction1$mcIJ$sp
trait JFunction1$mcJD$sp
trait JFunction1$mcJF$sp
trait JFunction1$mcJI$sp
trait JFunction1$mcJJ$sp
trait JFunction1$mcVD$sp
trait JFunction1$mcVF$sp
trait JFunction1$mcVI$sp
trait JFunction1$mcVJ$sp
trait JFunction1$mcZD$sp
trait JFunction1$mcZF$sp
trait JFunction1$mcZI$sp
trait JFunction1$mcZJ$sp
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => R
class AbstractFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => R
class AbstractFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => R
class AbstractFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => R
class AbstractFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => R
class AbstractFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) => R
class AbstractFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) => R
class AbstractFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) => R
class AbstractFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) => R
class AbstractFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) => R
class AbstractFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]
trait (T1, T2) => R
class FromJavaBiConsumer[T, U]
class FromJavaBiFunction[T, U, R]
class FromJavaBiPredicate[T, U]
class FromJavaBinaryOperator[T]
class FromJavaDoubleBinaryOperator
class FromJavaIntBinaryOperator
class FromJavaLongBinaryOperator
class FromJavaObjDoubleConsumer[T]
class FromJavaObjIntConsumer[T]
class FromJavaObjLongConsumer[T]
class FromJavaToDoubleBiFunction[T, U]
class FromJavaToIntBiFunction[T, U]
class FromJavaToLongBiFunction[T, U]
class AbstractFunction2[T1, T2, R]
trait JFunction2$mcDDD$sp
trait JFunction2$mcDDI$sp
trait JFunction2$mcDDJ$sp
trait JFunction2$mcDID$sp
trait JFunction2$mcDII$sp
trait JFunction2$mcDIJ$sp
trait JFunction2$mcDJD$sp
trait JFunction2$mcDJI$sp
trait JFunction2$mcDJJ$sp
trait JFunction2$mcFDD$sp
trait JFunction2$mcFDI$sp
trait JFunction2$mcFDJ$sp
trait JFunction2$mcFID$sp
trait JFunction2$mcFII$sp
trait JFunction2$mcFIJ$sp
trait JFunction2$mcFJD$sp
trait JFunction2$mcFJI$sp
trait JFunction2$mcFJJ$sp
trait JFunction2$mcIDD$sp
trait JFunction2$mcIDI$sp
trait JFunction2$mcIDJ$sp
trait JFunction2$mcIID$sp
trait JFunction2$mcIII$sp
trait JFunction2$mcIIJ$sp
trait JFunction2$mcIJD$sp
trait JFunction2$mcIJI$sp
trait JFunction2$mcIJJ$sp
trait JFunction2$mcJDD$sp
trait JFunction2$mcJDI$sp
trait JFunction2$mcJDJ$sp
trait JFunction2$mcJID$sp
trait JFunction2$mcJII$sp
trait JFunction2$mcJIJ$sp
trait JFunction2$mcJJD$sp
trait JFunction2$mcJJI$sp
trait JFunction2$mcJJJ$sp
trait JFunction2$mcVDD$sp
trait JFunction2$mcVDI$sp
trait JFunction2$mcVDJ$sp
trait JFunction2$mcVID$sp
trait JFunction2$mcVII$sp
trait JFunction2$mcVIJ$sp
trait JFunction2$mcVJD$sp
trait JFunction2$mcVJI$sp
trait JFunction2$mcVJJ$sp
trait JFunction2$mcZDD$sp
trait JFunction2$mcZDI$sp
trait JFunction2$mcZDJ$sp
trait JFunction2$mcZID$sp
trait JFunction2$mcZII$sp
trait JFunction2$mcZIJ$sp
trait JFunction2$mcZJD$sp
trait JFunction2$mcZJI$sp
trait JFunction2$mcZJJ$sp
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) => R
class AbstractFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) => R
class AbstractFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) => R
class AbstractFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]
trait (T1, T2, T3) => R
class AbstractFunction3[T1, T2, T3, R]
trait (T1, T2, T3, T4) => R
class AbstractFunction4[T1, T2, T3, T4, R]
trait (T1, T2, T3, T4, T5) => R
class AbstractFunction5[T1, T2, T3, T4, T5, R]
trait (T1, T2, T3, T4, T5, T6) => R
class AbstractFunction6[T1, T2, T3, T4, T5, T6, R]
trait (T1, T2, T3, T4, T5, T6, T7) => R
class AbstractFunction7[T1, T2, T3, T4, T5, T6, T7, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8) => R
class AbstractFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R]
trait (T1, T2, T3, T4, T5, T6, T7, T8, T9) => R
class AbstractFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]

Concrete methods

final def eq(x$0: Object): Boolean

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).

Value parameters
that

the object to compare against this object for reference equality.
Returns

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

final def ne(x$0: Object): Boolean

Equivalent to !(this eq that).

Value parameters
that

the object to compare against this object for reference equality.
Returns

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

final def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

Note

not specified by SLS as a member of AnyRef

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

Note

not specified by SLS as a member of AnyRef

final def synchronized[X0](x$0: X0): X0

Executes the code in body with an exclusive lock on this.

Value parameters
body

the code to execute
Returns

the result of body

final def wait(): Unit

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--.

Note

not specified by SLS as a member of AnyRef

final def wait(x$0: Long): Unit

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-.

Value parameters
timeout

the maximum time to wait in milliseconds.
Note

not specified by SLS as a member of AnyRef

final def wait(x$0: Long, x$1: Int): Unit

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-int-

Value parameters
nanos

additional time, in nanoseconds range 0-999999.

timeout

the maximum time to wait in milliseconds.
Note

not specified by SLS as a member of AnyRef

© 2002-2022 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://scala-lang.org/api/3.2.0/scala/AnyRef.html