The confusing thing to me is why can't float do simple additions without introducing error, like the .1 added 10 times? As a relatively large value compared to the .0...2, it shouldn't be introducing such an error that you get false boolean results such as ==1 is false. Or is that caused by something else that's even more out of my understanding?
The *why* isn't confusing at all. Modern computer languages use only binary floats. That means you can only represent numbers that are some sum of powers of two.
Like 1/4=0.25. Or 1/2+1/4=0.75.
0.2 is 1/5 and as such won't ever be expressed exactly in binary (because gcd(2,5)==1, they are both primes). You can get very close, but never exact. What happens when you print(0.2) is that the computer stores the internal binary representation of 0.2 (which is not equal to our 0.2), then it knows how to fool you by printing the shortest decimal number that would get converted to that binary representation (which is 0.2).
With doubles, this will also work for 1.2*5==6, because the result will accidentaly get rounded the right way, or something like that (or the FPU's multiplication tables are actually *wrong* in that they will say 1.199999999999992347615487652734 (or whatever that actually is) * 5 == 6. That's wrong if you look at the binary floats, but produces results that humans like better most of the time; but that would be cheating).
0.1 is even more far away from being exactly representable by a binary float (by exactly 1 bit of precision, incidentally), and 0.1d+0.1d is already potentially different from 0.2d (the double-precision number closest to 2*X is not necessarily the same as 2*the double-precision number closest to X, because you have that 1 bit of precision difference) (.. actually, 0.1d+0.1d==0.2d, but 0.1d+0.1d+0.1d!=0.3d, but 0.1d+0.1d+0.1d+0.1d==0.4d, but 0.1d+0.1d+0.1d+0.1d+0.1d!=0.5d ... there's a bit of something somewhere off due to how the rounding ends up being different for different numbers).
Also, *any* error greater than 0 will cause "false" comparison results. That's why you are supposed to always compare floats/doubles like "if (abs(a-b)<=tolerable_difference) { .... seems legit ... }"