Here are the practical differences between the different types:

Arrays are effectively ordered lists and are used to store lists of information in cases where order is important.

For example, posts in a social network app being displayed in a tableView may be stored in an array.

Sets are different in the sense that order does not matter and these will be used in cases where order does not matter.

Sets are especially useful when you need to ensure that an item only appears once in the set.

Dictionaries are used to store key, value pairs and are used when you want to easily find a value using a key, just like in a dictionary.

For example, you could store a list of items and links to more information about these items in a dictionary.

Hope this helps :)

(For more information and to find Apple's own definitions, check out Apple's guides at https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html)

There are several third-party libraries implementing an ordered set in Swift, so you could check them out.

Also, you could write your own implementation of an ordered set (you can base it on an existing one) if it is not an overkill for your task. The way you choose really depends on your app.

And in the end, you could use one of two ways that you proposed: using a built-in array or a set. In order to choose between them, take a look at your app: what action will be performed more often? Getting an access to elements in order (use array then) or addition/deletion of existing elements (probably, the set is the way to go).

This part was edited based on comments below

If you go for an array, note, that a built-in contains for arrays will not know that an array is sorted, so it will probably be O(N), not O(log(N)). So you should either write a custom replacement for the contains method, or (this is, once again probably a better way), write a custom collection class that implements contains the right way (however, since contains is a protocol extension method of SequenceType, my knowledge of Swift, I'm afraid, is not good enough yet to tell you how to do it properly, maybe someone else will).

UPDATE (based on your comment to your question):

I believe, in your particular case (a chat app) array is superior. You only have to sort old messages once, and you will not probably try to add very old messages once again, you only have to make sure you don't add new messages twice (it is implementation-dependent though, so you know better, I'm just assuming). So you only have to check that the last messages in your old array do not overlap with first messages in the array that you add. Sort of :)

Sets only allow unique elements in the collection.

For just 1000 objects it shouldn't really matter.

You may try the following test (for 1 million objects):

struct Foo: Hashable {
    let id: Int
    let name: String
}

let fooArr: [Foo] = (1...1_000_000).map { Foo(id: $0, name: "hkafghhkjdsgfajhkgfkjhasdf") }
let fooSet: Set<Foo> = Set(fooArr)

let start1 = CFAbsoluteTimeGetCurrent()
let filteredArr = fooArr.filter { $0.id.isMultiple(of: 2) }
let diff1 = CFAbsoluteTimeGetCurrent() - start1
print("Array: \(diff1) seconds")
// prints "Array: 4.004199028015137 seconds"

let start2 = CFAbsoluteTimeGetCurrent()
let filteredSetToArr = Array(fooSet.filter { $0.id.isMultiple(of: 2) })
let diff2 = CFAbsoluteTimeGetCurrent() - start2
print("Set: \(diff2) seconds")
// prints "Set: 4.139569997787476 seconds"

Again there isn't much of a difference. The actual values may differ but the relative difference should be similar for every try.

I used -Ofast optimisation level.

You can even make more detailed tests:

let fooArr: [Foo] = (1...1_000_000).map { Foo(id: $0, name: "hkafghhkjdsgfajhkgfkjhasdf") }
let fooSet: Set<Foo> = Set(fooArr)

let start1 = CFAbsoluteTimeGetCurrent()
let filteredArr = fooArr.filter { $0.id.isMultiple(of: 2) }
let diff1 = CFAbsoluteTimeGetCurrent() - start1
print("Array filtering: \(diff1) seconds")

let start2 = CFAbsoluteTimeGetCurrent()
let filteredSet = Array(fooSet.filter { $0.id.isMultiple(of: 2) })
let diff2 = CFAbsoluteTimeGetCurrent() - start2
print("Set filtering: \(diff2) seconds")

let start3 = CFAbsoluteTimeGetCurrent()
let filteredSetToArr = Array(filteredSet)
let diff3 = CFAbsoluteTimeGetCurrent() - start3
print("Set to Array: \(diff3) seconds")

print("Set total: \(diff2 + diff3) seconds")

and the result will be:

Array filtering: 1.5497009754180908 seconds
Set filtering: 1.2836240530014038 seconds
Set to Array: 1.895427703857422e-05 seconds
Set total: 1.2836430072784424 seconds

Note that filtering is way more expensive than conversion from Set to Array.