RealmQuery (Realm 3.1.2)

java.lang.Object
- io.realm.RealmQuery<E>

Type Parameters:

E - the class of the objects to be queried.
```
public class RealmQuery<E extends RealmModel>
extends Object
```
A RealmQuery encapsulates a query on a Realm or a RealmResults using the Builder pattern. The query is executed using either findAll() or findFirst().
The input to many of the query functions take a field name as String. Note that this is not type safe. If a RealmObject class is refactored care has to be taken to not break any queries.
A Realm is unordered, which means that there is no guarantee that querying a Realm will return the objects in the order they where inserted. Use findAllSorted(String) and similar methods if a specific order is required.
A RealmQuery cannot be passed between different threads.

See Also:

Builder pattern, Realm.where(Class), RealmResults.where()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`average(String fieldName)` Returns the average of a given field.
`RealmQuery<E>`	`beginGroup()` Begin grouping of conditions ("left parenthesis").
`RealmQuery<E>`	`beginsWith(String fieldName, String value)` Condition that the value of field begins with the specified string.
`RealmQuery<E>`	`beginsWith(String fieldName, String value, Case casing)` Condition that the value of field begins with the specified substring.
`RealmQuery<E>`	`between(String fieldName, Date from, Date to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, double from, double to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, float from, float to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, int from, int to)` Between condition.
`RealmQuery<E>`	`between(String fieldName, long from, long to)` Between condition.
`RealmQuery<E>`	`contains(String fieldName, String value)` Condition that value of field contains the specified substring.
`RealmQuery<E>`	`contains(String fieldName, String value, Case casing)` Condition that value of field contains the specified substring.
`long`	`count()` Counts the number of objects that fulfill the query conditions.
`static <E extends RealmModel> RealmQuery<E>`	`createDynamicQuery(DynamicRealm realm, String className)` Creates a query for dynamic objects of a given type from a `DynamicRealm`.
`static <E extends RealmModel> RealmQuery<E>`	`createQuery(Realm realm, Class<E> clazz)` Creates a query for objects of a given class from a `Realm`.
`static <E extends RealmModel> RealmQuery<E>`	`createQueryFromList(RealmList<E> list)` Creates a query from an existing `RealmList`.
`static <E extends RealmModel> RealmQuery<E>`	`createQueryFromResult(RealmResults<E> queryResults)` Creates a query from an existing `RealmResults`.
`RealmResults<E>`	`distinct(String fieldName)` Returns a distinct set of objects of a specific class.
`RealmResults<E>`	`distinct(String firstFieldName, String... remainingFieldNames)` Returns a distinct set of objects from a specific class.
`RealmResults<E>`	`distinctAsync(String fieldName)` Asynchronously returns a distinct set of objects of a specific class.
`RealmQuery<E>`	`endGroup()` End grouping of conditions ("right parenthesis") which was opened by a call to `beginGroup()`.
`RealmQuery<E>`	`endsWith(String fieldName, String value)` Condition that the value of field ends with the specified string.
`RealmQuery<E>`	`endsWith(String fieldName, String value, Case casing)` Condition that the value of field ends with the specified substring.
`RealmQuery<E>`	`equalTo(String fieldName, Boolean value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Byte value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, byte[] value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Date value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Double value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Float value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Integer value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Long value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, Short value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, String value)` Equal-to comparison.
`RealmQuery<E>`	`equalTo(String fieldName, String value, Case casing)` Equal-to comparison.
`RealmResults<E>`	`findAll()` Finds all objects that fulfill the query conditions.
`RealmResults<E>`	`findAllAsync()` Finds all objects that fulfill the query conditions and sorted by specific field name.
`RealmResults<E>`	`findAllSorted(String fieldName)` Finds all objects that fulfill the query conditions and sorted by specific field name in ascending order.
`RealmResults<E>`	`findAllSorted(String[] fieldNames, Sort[] sortOrders)` Finds all objects that fulfill the query conditions and sorted by specific field names.
`RealmResults<E>`	`findAllSorted(String fieldName, Sort sortOrder)` Finds all objects that fulfill the query conditions and sorted by specific field name.
`RealmResults<E>`	`findAllSorted(String fieldName1, Sort sortOrder1, String fieldName2, Sort sortOrder2)` Finds all objects that fulfill the query conditions and sorted by specific field names in ascending order.
`RealmResults<E>`	`findAllSortedAsync(String fieldName)` Similar to `findAllSorted(String)` but runs asynchronously on a worker thread.
`RealmResults<E>`	`findAllSortedAsync(String[] fieldNames, Sort[] sortOrders)` Similar to `findAllSorted(String[], Sort[])` but runs asynchronously.
`RealmResults<E>`	`findAllSortedAsync(String fieldName, Sort sortOrder)` Similar to `findAllSorted(String, Sort)` but runs asynchronously on a worker thread (need a Realm opened from a looper thread to work).
`RealmResults<E>`	`findAllSortedAsync(String fieldName1, Sort sortOrder1, String fieldName2, Sort sortOrder2)` Similar to `findAllSorted(String, Sort, String, Sort)` but runs asynchronously on a worker thread This method is only available from a Looper thread.
`E`	`findFirst()` Finds the first object that fulfills the query conditions.
`E`	`findFirstAsync()` Similar to `findFirst()` but runs asynchronously on a worker thread.
`RealmQuery<E>`	`greaterThan(String fieldName, Date value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, double value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, float value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, int value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThan(String fieldName, long value)` Greater-than comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, Date value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, double value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, float value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, int value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`greaterThanOrEqualTo(String fieldName, long value)` Greater-than-or-equal-to comparison.
`RealmQuery<E>`	`in(String fieldName, Boolean[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Byte[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Date[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Double[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Float[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Integer[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Long[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, Short[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, String[] values)` In comparison.
`RealmQuery<E>`	`in(String fieldName, String[] values, Case casing)` In comparison.
`RealmQuery<E>`	`isEmpty(String fieldName)` Condition that finds values that are considered "empty" i.e., an empty list, the 0-length string or byte array.
`RealmQuery<E>`	`isNotEmpty(String fieldName)` Condition that finds values that are considered "Not-empty" i.e., a list, a string or a byte array with not-empty values.
`RealmQuery<E>`	`isNotNull(String fieldName)` Tests if a field is not `null`.
`RealmQuery<E>`	`isNull(String fieldName)` Tests if a field is `null`.
`boolean`	`isValid()` Checks if `RealmQuery` is still valid to use i.e., the `Realm` instance hasn't been closed and any parent `RealmResults` is still valid.
`RealmQuery<E>`	`lessThan(String fieldName, Date value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, double value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, float value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, int value)` Less-than comparison.
`RealmQuery<E>`	`lessThan(String fieldName, long value)` Less-than comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, Date value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, double value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, float value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, int value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`lessThanOrEqualTo(String fieldName, long value)` Less-than-or-equal-to comparison.
`RealmQuery<E>`	`like(String fieldName, String value)` Condition that the value of field matches with the specified substring, with wildcards: '*' matches [0, n] unicode chars '?' matches a single unicode char.
`RealmQuery<E>`	`like(String fieldName, String value, Case casing)` Condition that the value of field matches with the specified substring, with wildcards: '*' matches [0, n] unicode chars '?' matches a single unicode char.
`Number`	`max(String fieldName)` Finds the maximum value of a field.
`Date`	`maximumDate(String fieldName)` Finds the maximum value of a field.
`Number`	`min(String fieldName)` Finds the minimum value of a field.
`Date`	`minimumDate(String fieldName)` Finds the minimum value of a field.
`RealmQuery<E>`	`not()` Negate condition.
`RealmQuery<E>`	`notEqualTo(String fieldName, Boolean value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Byte value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, byte[] value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Date value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Double value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Float value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Integer value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Long value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, Short value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, String value)` Not-equal-to comparison.
`RealmQuery<E>`	`notEqualTo(String fieldName, String value, Case casing)` Not-equal-to comparison.
`RealmQuery<E>`	`or()` Logical-or two conditions.
`Number`	`sum(String fieldName)` Calculates the sum of a given field.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - createQuery
```
public static <E extends RealmModel> RealmQuery<E> createQuery(Realm realm,
                                                               Class<E> clazz)
```
    Creates a query for objects of a given class from a Realm.
    
    Parameters:
    
    realm - the realm to query within.
    
    clazz - the class to query.
    
    Returns:
    
    RealmQuery object. After building the query call one of the find* methods to run it.
  - createDynamicQuery
```
public static <E extends RealmModel> RealmQuery<E> createDynamicQuery(DynamicRealm realm,
                                                                      String className)
```
    Creates a query for dynamic objects of a given type from a DynamicRealm.
    
    Parameters:
    
    realm - the realm to query within.
    
    className - the type to query.
    
    Returns:
    
    RealmQuery object. After building the query call one of the find* methods to run it.
  - createQueryFromResult
```
public static <E extends RealmModel> RealmQuery<E> createQueryFromResult(RealmResults<E> queryResults)
```
    Creates a query from an existing RealmResults.
    
    Parameters:
    
    queryResults - an existing @{link io.realm.RealmResults} to query against.
    
    Returns:
    
    RealmQuery object. After building the query call one of the find* methods to run it.
  - createQueryFromList
```
public static <E extends RealmModel> RealmQuery<E> createQueryFromList(RealmList<E> list)
```
    Creates a query from an existing RealmList.
    
    Parameters:
    
    list - an existing @{link io.realm.RealmList} to query against.
    
    Returns:
    
    RealmQuery object. After building the query call one of the find* methods to run it.
  - isValid
```
public boolean isValid()
```
    Checks if RealmQuery is still valid to use i.e., the Realm instance hasn't been closed and any parent RealmResults is still valid.
    
    Returns:
    
    true if still valid to use, false otherwise.
  - isNull
```
public RealmQuery<E> isNull(String fieldName)
```
    Tests if a field is null. Only works for nullable fields.
    For link queries, if any part of the link path is null the whole path is considered to be null e.g., isNull("linkField.stringField") will be considered to be null if either linkField or linkField.stringField is null.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field is not nullable.
    
    See Also:
    
    for further infomation.
  - isNotNull
```
public RealmQuery<E> isNotNull(String fieldName)
```
    Tests if a field is not null. Only works for nullable fields.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field is not nullable.
    
    See Also:
    
    for further infomation.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             String value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             String value,
                             Case casing)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Byte value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             byte[] value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Short value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Integer value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Long value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Double value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Float value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    The query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Boolean value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - equalTo
```
public RealmQuery<E> equalTo(String fieldName,
                             Date value)
```
    Equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - in
```
public RealmQuery<E> in(String fieldName,
                        String[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a String field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        String[] values,
                        Case casing)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    casing - how casing is handled. Case.INSENSITIVE works only for the Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a String field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Byte[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Byte field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Short[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Short field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Integer[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Integer field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Long[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Long field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Double[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Double field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Float[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Float field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Boolean[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Boolean field or values is null or empty.
  - in
```
public RealmQuery<E> in(String fieldName,
                        Date[] values)
```
    In comparison. This allows you to test if objects match any value in an array of values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    values - array of values to compare with and it cannot be null or empty.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field isn't a Date field or values is null or empty.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                String value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                String value,
                                Case casing)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    casing - how casing is handled. Case.INSENSITIVE works only for the Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Byte value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                byte[] value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Short value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Integer value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Long value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Double value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Float value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Boolean value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - notEqualTo
```
public RealmQuery<E> notEqualTo(String fieldName,
                                Date value)
```
    Not-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 int value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 long value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 double value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 float value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThan
```
public RealmQuery<E> greaterThan(String fieldName,
                                 Date value)
```
    Greater-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          int value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          long value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          double value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          float value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type
  - greaterThanOrEqualTo
```
public RealmQuery<E> greaterThanOrEqualTo(String fieldName,
                                          Date value)
```
    Greater-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              int value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              long value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              double value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              float value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThan
```
public RealmQuery<E> lessThan(String fieldName,
                              Date value)
```
    Less-than comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       int value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       long value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       double value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       float value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - lessThanOrEqualTo
```
public RealmQuery<E> lessThanOrEqualTo(String fieldName,
                                       Date value)
```
    Less-than-or-equal-to comparison.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the value to compare with.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             int from,
                             int to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             long from,
                             long to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             double from,
                             double to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             float from,
                             float to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - between
```
public RealmQuery<E> between(String fieldName,
                             Date from,
                             Date to)
```
    Between condition.
    
    Parameters:
    
    fieldName - the field to compare.
    
    from - lowest value (inclusive).
    
    to - highest value (inclusive).
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - contains
```
public RealmQuery<E> contains(String fieldName,
                              String value)
```
    Condition that value of field contains the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - contains
```
public RealmQuery<E> contains(String fieldName,
                              String value,
                              Case casing)
```
    Condition that value of field contains the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    The query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginsWith
```
public RealmQuery<E> beginsWith(String fieldName,
                                String value)
```
    Condition that the value of field begins with the specified string.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginsWith
```
public RealmQuery<E> beginsWith(String fieldName,
                                String value,
                                Case casing)
```
    Condition that the value of field begins with the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - endsWith
```
public RealmQuery<E> endsWith(String fieldName,
                              String value)
```
    Condition that the value of field ends with the specified string.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - endsWith
```
public RealmQuery<E> endsWith(String fieldName,
                              String value,
                              Case casing)
```
    Condition that the value of field ends with the specified substring.
    
    Parameters:
    
    fieldName - the field to compare.
    
    value - the substring.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - like
```
public RealmQuery<E> like(String fieldName,
                          String value)
```
    Condition that the value of field matches with the specified substring, with wildcards:
    - '*' matches [0, n] unicode chars
    - '?' matches a single unicode char.
    Parameters:
    
    fieldName - the field to compare.
    
    value - the wildcard string.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - like
```
public RealmQuery<E> like(String fieldName,
                          String value,
                          Case casing)
```
    Condition that the value of field matches with the specified substring, with wildcards:
    - '*' matches [0, n] unicode chars
    - '?' matches a single unicode char.
    Parameters:
    
    fieldName - the field to compare.
    
    value - the wildcard string.
    
    casing - how to handle casing. Setting this to Case.INSENSITIVE only works for Latin-1 characters.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if one or more arguments do not match class or field type.
  - beginGroup
```
public RealmQuery<E> beginGroup()
```
    Begin grouping of conditions ("left parenthesis"). A group must be closed with a call to endGroup().
    
    Returns:
    
    the query object.
    
    See Also:
    
    endGroup()
  - endGroup
```
public RealmQuery<E> endGroup()
```
    End grouping of conditions ("right parenthesis") which was opened by a call to beginGroup().
    
    Returns:
    
    the query object.
    
    See Also:
    
    beginGroup()
  - or
```
public RealmQuery<E> or()
```
    Logical-or two conditions.
    
    Returns:
    
    the query object.
  - not
```
public RealmQuery<E> not()
```
    Negate condition.
    
    Returns:
    
    the query object.
  - isEmpty
```
public RealmQuery<E> isEmpty(String fieldName)
```
    Condition that finds values that are considered "empty" i.e., an empty list, the 0-length string or byte array.
    
    Parameters:
    
    fieldName - the field to compare.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field name isn't valid or its type isn't either a RealmList, String or byte array.
  - isNotEmpty
```
public RealmQuery<E> isNotEmpty(String fieldName)
```
    Condition that finds values that are considered "Not-empty" i.e., a list, a string or a byte array with not-empty values.
    
    Parameters:
    
    fieldName - the field to compare.
    
    Returns:
    
    the query object.
    
    Throws:
    
    IllegalArgumentException - if the field name isn't valid or its type isn't either a RealmList, String or byte array.
  - distinct
```
public RealmResults<E> distinct(String fieldName)
```
    Returns a distinct set of objects of a specific class. If the result is sorted, the first object will be returned in case of multiple occurrences, otherwise it is undefined which object is returned.
    Adding Index to the corresponding field will make this operation much faster.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    a non-null RealmResults containing the distinct objects.
    
    Throws:
    
    IllegalArgumentException - if a field is null, does not exist, is an unsupported type, or points to linked fields.
  - distinctAsync
```
public RealmResults<E> distinctAsync(String fieldName)
```
    Asynchronously returns a distinct set of objects of a specific class. If the result is sorted, the first object will be returned in case of multiple occurrences, otherwise it is undefined which object is returned. Adding Index to the corresponding field will make this operation much faster.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    immediately a RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalArgumentException - if a field is null, does not exist, is an unsupported type, or points to linked fields.
  - distinct
```
public RealmResults<E> distinct(String firstFieldName,
                                String... remainingFieldNames)
```
    Returns a distinct set of objects from a specific class. When multiple distinct fields are given, all unique combinations of values in the fields will be returned. In case of multiple matches, it is undefined which object is returned. Unless the result is sorted, then the first object will be returned.
    
    Parameters:
    
    firstFieldName - first field name to use when finding distinct objects.
    
    remainingFieldNames - remaining field names when determining all unique combinations of field values.
    
    Returns:
    
    a non-null RealmResults containing the distinct objects.
    
    Throws:
    
    IllegalArgumentException - if field names is empty or null, does not exist, is an unsupported type, or points to a linked field.
  - sum
```
public Number sum(String fieldName)
```
    Calculates the sum of a given field.
    
    Parameters:
    
    fieldName - the field to sum. Only number fields are supported.
    
    Returns:
    
    the sum of fields of the matching objects. If no objects exist or they all have null as the value for the given field, 0 will be returned. When computing the sum, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - average
```
public double average(String fieldName)
```
    Returns the average of a given field.
    
    Parameters:
    
    fieldName - the field to calculate average on. Only number fields are supported.
    
    Returns:
    
    the average for the given field amongst objects in query results. This will be of type double for all types of number fields. If no objects exist or they all have null as the value for the given field, 0 will be returned. When computing the average, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - min
```
public Number min(String fieldName)
```
    Finds the minimum value of a field.
    
    Parameters:
    
    fieldName - the field to look for a minimum on. Only number fields are supported.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given field, null will be returned. Otherwise the minimum value is returned. When determining the minimum value, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - minimumDate
```
public Date minimumDate(String fieldName)
```
    Finds the minimum value of a field.
    
    Parameters:
    
    fieldName - the field name
    
    Returns:
    
    if no objects exist or they all have null as the value for the given date field, null will be returned. Otherwise the minimum date is returned. When determining the minimum date, objects with null values are ignored.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - max
```
public Number max(String fieldName)
```
    Finds the maximum value of a field.
    
    Parameters:
    
    fieldName - the field to look for a maximum on. Only number fields are supported.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given field, null will be returned. Otherwise the maximum value is returned. When determining the maximum value, objects with null values are ignored.
    
    Throws:
    
    IllegalArgumentException - if the field is not a number type.
  - maximumDate
```
public Date maximumDate(String fieldName)
```
    Finds the maximum value of a field.
    
    Parameters:
    
    fieldName - the field name.
    
    Returns:
    
    if no objects exist or they all have null as the value for the given date field, null will be returned. Otherwise the maximum date is returned. When determining the maximum date, objects with null values are ignored.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - count
```
public long count()
```
    Counts the number of objects that fulfill the query conditions.
    
    Returns:
    
    the number of matching objects.
    
    Throws:
    
    UnsupportedOperationException - if the query is not valid ("syntax error").
  - findAll
```
public RealmResults<E> findAll()
```
    Finds all objects that fulfill the query conditions.
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    See Also:
    
    RealmResults
  - findAllAsync
```
public RealmResults<E> findAllAsync()
```
    Finds all objects that fulfill the query conditions and sorted by specific field name. This method is only available from a Looper thread.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    See Also:
    
    RealmResults
  - findAllSorted
```
public RealmResults<E> findAllSorted(String fieldName,
                                     Sort sortOrder)
```
    Finds all objects that fulfill the query conditions and sorted by specific field name.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName - the field name to sort by.
    
    sortOrder - how to sort the results.
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    Throws:
    
    IllegalArgumentException - if field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSortedAsync
```
public RealmResults<E> findAllSortedAsync(String fieldName,
                                          Sort sortOrder)
```
    Similar to findAllSorted(String, Sort) but runs asynchronously on a worker thread (need a Realm opened from a looper thread to work).
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalArgumentException - if field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSorted
```
public RealmResults<E> findAllSorted(String fieldName)
```
    Finds all objects that fulfill the query conditions and sorted by specific field name in ascending order.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName - the field name to sort by.
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSortedAsync
```
public RealmResults<E> findAllSortedAsync(String fieldName)
```
    Similar to findAllSorted(String) but runs asynchronously on a worker thread. This method is only available from a Looper thread.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalArgumentException - if the field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSorted
```
public RealmResults<E> findAllSorted(String[] fieldNames,
                                     Sort[] sortOrders)
```
    Finds all objects that fulfill the query conditions and sorted by specific field names.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldNames - an array of field names to sort by.
    
    sortOrders - how to sort the field names.
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    Throws:
    
    IllegalArgumentException - if one of the field names does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSortedAsync
```
public RealmResults<E> findAllSortedAsync(String[] fieldNames,
                                          Sort[] sortOrders)
```
    Similar to findAllSorted(String[], Sort[]) but runs asynchronously. from a worker thread. This method is only available from a Looper thread.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalArgumentException - if one of the field names does not exist or it belongs to a child RealmObject or a child RealmList.
    
    See Also:
    
    RealmResults
  - findAllSorted
```
public RealmResults<E> findAllSorted(String fieldName1,
                                     Sort sortOrder1,
                                     String fieldName2,
                                     Sort sortOrder2)
```
    Finds all objects that fulfill the query conditions and sorted by specific field names in ascending order.
    Sorting is currently limited to character sets in 'Latin Basic', 'Latin Supplement', 'Latin Extended A', 'Latin Extended B' (UTF-8 range 0-591). For other character sets, sorting will have no effect.
    
    Parameters:
    
    fieldName1 - first field name
    
    sortOrder1 - sort order for first field
    
    fieldName2 - second field name
    
    sortOrder2 - sort order for second field
    
    Returns:
    
    a RealmResults containing objects. If no objects match the condition, a list with zero objects is returned.
    
    Throws:
    
    IllegalArgumentException - if a field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findAllSortedAsync
```
public RealmResults<E> findAllSortedAsync(String fieldName1,
                                          Sort sortOrder1,
                                          String fieldName2,
                                          Sort sortOrder2)
```
    Similar to findAllSorted(String, Sort, String, Sort) but runs asynchronously on a worker thread This method is only available from a Looper thread.
    
    Returns:
    
    immediately an empty RealmResults. Users need to register a listener RealmResults.addChangeListener(RealmChangeListener) to be notified when the query completes.
    
    Throws:
    
    IllegalArgumentException - if a field name does not exist or it belongs to a child RealmObject or a child RealmList.
  - findFirst
```
public E findFirst()
```
    Finds the first object that fulfills the query conditions.
    
    Returns:
    
    the object found or null if no object matches the query conditions.
    
    See Also:
    
    RealmObject
  - findFirstAsync
```
public E findFirstAsync()
```
    Similar to findFirst() but runs asynchronously on a worker thread. An listener should be registered to the returned RealmObject to get the notification when query completes. The registered listener will also be triggered if there are changes made to the queried RealmObject. If the RealmObject is deleted, the listener will be called one last time and then stop. The query will not be re-run.
    
    Returns:
    
    immediately an empty RealmObject with isLoaded() == false. Trying to access any field on the returned object before it is loaded will throw an IllegalStateException.
    
    Throws:
    
    IllegalStateException - if this is called on a non-looper thread.

Class RealmQuery<E extends RealmModel>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

createQuery

createDynamicQuery

createQueryFromResult

createQueryFromList

isValid

isNull

isNotNull

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

equalTo

in

in

in

in

in

in

in

in

in

in

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

notEqualTo

greaterThan

greaterThan

greaterThan

greaterThan

greaterThan

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

greaterThanOrEqualTo

lessThan

lessThan

lessThan

lessThan

lessThan

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

lessThanOrEqualTo

between

between

between

between

between

contains

contains

beginsWith

beginsWith

endsWith

endsWith

like

like

beginGroup

endGroup

or

not