We could reverse that on you and say that C# is more complicated than Java and a pain in the ass to use. Please leave your bias at the door.
Not really. Here's why.
C# is a superset of Java. Everything that you can do in Java, you can do in C# with minimal modification (such as type name changes). A java class will be valid C#.
However, C# supports treating primitives like objects. Java's type system does not. In Java you have (as types that can be represented by literals):
byte
short
int
long
float
double
Object
|-> String
In C# you have:
Object
|-> byte
|-> sbyte
|-> short
|-> ushort
|-> int
|-> uint
|-> long
|-> ulong
|-> float
|-> double
|-> decimal
|-> string
(Technically, all of the numerics in C# inherit from System.ValueType, but that's an internal compiler detail since ValueType isn't really used in any instance ever).
Because in C# all primitives are actually Objects, we can do something like so:
ArrayList al = new ArrayList();
al.Add(1);
al.Add(4485);
al.Add("This is a string.");
In Java, you can't; you have to provide the class wrapper (except in the case of strings):
al.add(new Integer(1));
al.add(new Integer(4485));
al.add("This is a string.");
Also, because C# supports overloaded operator this[], ArrayList can be treated like an array, which makes its syntax cleaner. Example:
int val = (int)al[0];
int val2 = (int)al[1];
string val3 = al[2] as string;
In Java you'd have to:
int val = ((Integer)al.get(0)).intValue();
int val2 = ((Integer)al.get(1)).intValue();
String val3 = (String)al.get(2);
Note also that the semantic difference between the C# and Java implementations of getting "val3" are important. In C#, if the third ArrayList element is not a String-compatible type, val3 will be null. In Java, because you're forced to do typecasting in this way, you run the risk of generating a ClassCastException. If you cast that way in C# you can generate an InvalidCastException as well. The point is that you don't need to cast reference types in a way that generates an unnecessary exception.
I haven't even begun to talk about all other ways that Java is a pain in the ass - such as the necessity of an additional class where function pointers would suffice (Runnable, for example, vs. a ThreadStart calback in C#).