As it turns out, an iPhone 6 with 1GB of RAM runs much faster than a similarly specced Android smartphone with 2GB of RAM. And it all has to do with the fundamental difference in the way iOS and Android handle apps.
[Explanation that Android apps use garbage-collected Java, while IOS does not, and that garbage-collected apps require 4-8 times as much RAM.]
This is why Android devices need to have twice as much RAM to run apps as your iPhone does.
Did the iPhone 6 run as fast as an Android phone with twice as much memory, in 2014, due to more efficient memory management?
This is a question loaded with nuances, and has since been overtaken by events.
The short answer is: when that article was written back in 2014, that might have been somewhat true. Today, it is either not true, or not nearly as true.
One flaw in that article is that there are no hard measurements, as in comparing two nearly identical apps on both systems. So the statement that iOS is 'twice as efficient' is pure hyperbole, because the author made no attempt to validate this. iOS might be more than twice as efficient, or it might be only 50% more efficient. Much is dependent on what the app is doing, and how the developer wrote the app.
It is important to make a distinction between static RAM, where apps and images are stored when they aren't being used, and dynamic RAM, which is quite a bit faster, where apps and images (and other things) are stored while the app is actually running. You can buy a phone with 64 gig of memory, but that's slow static RAM. High speed dynamic RAM is quite a bit more pricey, which is why iPhones tend to have 1 gig of DRAM, while Android phones have 2. Another reason SRAM is used is - it doesn't lose its contents when the power is turned off, while DRAM does lose it's contents on power down.
According to the article, iOS is more efficient than Android because Android apps are based on Java, and subject to periodic 'garbage collection', while iOS apps are not.
This all revolves around how an app uses the phone's DRAM while it is running. The app will have whatever images it displays in DRAM, and it will have whatever data it needs, maybe from internal sources (such as a game) or maybe from a server (news grazer), also held in DRAM. When the developer writes the app, they allocate DRAM memory as they need it.
Java manages memory for the software developer, freeing the developer from the need to free up memory that they have used. True that this isn't necessarily the most efficient approach, in that used memory can pile up until Java goes and clears out what isn't being used any more.
Originally, iOS apps required the developer to do this. It's a more efficient approach, but much more tedious. The upside is: a well written iOS app will use a minimum of memory, and will return that memory for usage as soon as possible. The downside is: when the developer has to manage all memory, it takes a lot longer to develop the app. And, if the developer doesn't get it exactly right, their app has a 'memory leak', in that they forgot to free up some memory they used, and the app will continue to consume memory until it has used all available DRAM, and the phone crashes.
So, originally, while iOS apps were more of a headache to develop, they tended to be more efficient and load faster than Java based Android apps, because the developer took care of memory management, which is more efficient than Java doing it for you. That was true as of when that article was written: 2014.
I say 'originally', because as of 2018, both of the development methods for iOS: Objective-C and SWIFT, also have a Java like garbage collection management method to relieve the developer of that tedious task, so they are now in the same boat as Java... with a 'garbage collector' that frees up DRAM memory the app no longer uses.
I am currently working on a system that has both Android and iOS client apps that do the same thing. While iOS in general tends to be simpler to develop apps for - Android's development tools can be maddeningly inconsistent at times - and iOS has a richer set of features the developer can use, I haven't seen that the iOS app is really much more efficient than Android when performing the same task.
That's comparing two apps that do the same task, with the iOS app written in Objective-C, with the automatic garbage collection turned on. (the developer can turn this off, if they're feeling particularly masochistic)