Time Complexity of Realm Lists in Swift - swift

Question

I was wondering how the Realm Lists were implemented in swift. To be more specific, I was wondering if they are Linked Lists or if they work similarly to Array Lists. For example, what would the time complexity of retrieving an item at an index be. Let's say I have Realm List A of length m and I want to retrieve A[n], would this operation run in O(n) like a Linked List or O(k) like in an Array List.
Edit:
Here is a little more clarification to the question:
Let's say I want to store my user's friend list in a Realm Database. The way I would do this is by defining a new Class User as follows:
Class User: Object{
#objc dynamic var name: String?
#objc dynamic var userName: String?
#objc dynamic var email: String?
var friendList = RealmSwift.List<String>() //Contains the names of all friends
}
Let's say that I've added some friends to my user's friendList and somewhere else in my app I want to access this friend list and display a specific friend as such:
var realm = try! Realm()
var user = realm.objects(User.self)[0]
var friendToDisplay = user.friendList[4]
print(friendToDisplay)
I'm wondering what is the time complexity of the user.friendList[4] operation. If Realm would treat the RealmSwift.List as a linked list, then the complexity would have to be O(n) while if when user is called to memory, RealmSwift.List is implemented as an ArrayList then accessing the fourth memory address in the list would be O(1).
My curiosity comes from wondering which would be faster:
Looping through the List and finding the name of the friend we want to display as such:
var realm = try! Realm()
var user = realm.objects(User.self)[0]
var friendName = "Peter"
for friend in user.friendList{
if friend == friendName {
print(friend)
}
}
or
Knowing the index of the friend we want to display let's say index 4 as such:
var realm = try! Realm()
var user = realm.objects(User.self)[0]
var friendToDisplay = user.friendList[4]
print(friendToDisplay)
In both of the cases let's say that the friend's name or the index that we are using exist in the friendList List.

Answer 1

The question is not going to be directly answerable due to the number of variables involved and the inherent nature of Realm. I will provide some info but let me clarify one point that's important.
Realm doesn't support primitives in Lists (very well).
EDIT: Release 10.7 added support for filters/queries as well as aggregate functions on primitives so the below info is no longer completely valid. However, it's still something to be aware of.
So you won't want to do this
var friendList = RealmSwift.List<String>()
You will however want to define a FriendClass that holds details about your friend
class FriendClass: Object {
#objc dynamic var friendName = ""
}
and then do this
let friendList = List<FriendClass>()
Now on to your question:
Your question asks about finding a friend by looping through a list or knowing the index. While you can do either programmatically, neither is an ideal solution.
If you want to want to find your FriendClass object for your friend Peter, this is the fastest way to do it
if let peter = realm.objects(FriendClass.self).filter("friendName == 'Peter'").first {
//do something with the peter object
}
keep in mind that is working with ALL of the friend objects in realm. You can likewise perform the same thing on a specific list instead. So if your user object has a friendsList list:
if let peter = user.friendsList.filter("friendName == 'Peter'").first {
//do something with the peter object
}
Here's the variable bit: Realm objects are lazily loaded. This allows Realm to contain millions of objects but not load them into memory until they are needed. That prevents overwhelming the device.
That's a huge variable as things like disk access and if the object is already loaded can have an impact. However, using the technique I presented above, whether it's one or 10,000 friends in your friends list the query is virtually instantaneous.
One of our projects has 10GB of data to which a filter like shown above presents an immediate response from Realm.
Now here come the other variables:
Primary Keys
If your objects have primary keys you can directly read that object without messing about
let peter = realm.object(ofType: FriendClass.self, forPrimaryKey: "peters key")
For clarity, objects with primary keys take O(log n) time. n is the number of objects of that type in the database. In a nutshell, the time it takes to retrieve a friend is unrelated to the number total objects in Realm.
Indexing
Indexed objects make writes a tad slower but make queries faster which, in the above example, if name were set as a indexedProperty it would increase the over all read speed when querying on that property
Lists
A list is another layer if indirection which, generally speaking would be 'slower' than reading objects directly. That being said, 'slower' is highly subjective and relative to the use case. Taking .03 seconds to retrieve a friend from a list of 100,000 is not impactful.