That is the understatement of this century in my opinion.
If you are doing NO screen I/O, then Android is hands down easier for developer to use. Java is simply faster to code in than Objective-C (unless you have years of experience). But the second you have to deal with the screen that is when Android becomes a nightmare. Let me layout the differences so you get an idea what Android developers have to worry about.
Under iOS you have two target coordinate systems to code against.
1) 480 x 320
2) 1024 x 768
Notice I didn't show Retina? That is screen resolution and a different animal than coordinate system.
So lets list them next: 480 x 320, 960 x 640, 1024 x 768 and 2048 x 1536.
This produces four "screen densities". 163 PPI (Pixels Per Inch) and 326 PPI for the iPhones. 133 PPI and 266 PPI for the iPads.
That's it. Predictable and easy for the developer to handle. BTW to activate Retina graphics developers simply have to place graphics into proper resource area of XCode and add @2x to the end of the file name before .png. iOS automatically selects from the four sets of graphics which one to use for the iOS device you are on. Apple REALLY thought this thru.
Under Android you have to deal with 14 coordinate systems (and this list can change with the introduction of a new device):
1) 240 × 320
2) 320 x 480
3) 340 x 480
4) 360 x 640
5) 480 x 640
6) 480 x 800
7) 480 x 854
8) 540 x 960
9) 640 x 960
10) 800 x 600
11) 1024 x 600
12) 1024 x 768
13) 1280 x 720
14) 1280 x 800
Now how the heck is a developer supposed to deal with this? Well them tried to make it easy. Each one of those coordinate systems falls into one of four screen size (3 to 10+ inches) and one of four screen densities (Pixel Per Inch). And remember they make a 5" display with 1280 x 720 and a 10" display with 1280 x 720. That means your PPI difference is HUGE and requires major differences for text display.
Android allows you to code against one of four systems. Pure coordinate (good luck with that), screen resolution groups (small, normal, large, xlarge), screen density (ldpi, mdpi, hdpi, xhdpi) and finally density independent pixels. Lets discuss the one that is used the most.
Screen density allows you to use an XML screen layout to approximate where you want to position your screen assets (text, buttons, graphics) and the device has the necessary math to convert your code to its screen. That means an application will "approximately" look the same across all devices. Yes, some of those devices will have "blank areas" because the screen resolution simply doesn't work out math wise. And now a quick mention about Density Independent Pixels. It is basically a mathematical way to help resolve Screen Density (the four l, m, h, xh DPIs) divided by the true display density. This gives you the proper offsets for the target display.
BTW, if a manufacture doesn't put in the proper information for Android to use for all of the screen calculations, it doesn't matter how much work the developer does, the screen just isn't going to look right. This happened a lot when the first tablets were introduced.
So now you know the back story of why Android is a nightmare and why Apple got it right