Hell, just look at "Hello world" in Java to see part of the problem. You have to create a class, then create a method main() within that class, then use a very lengthy absolute path to the method to send out put to the screen (System.out.println()). On top of that, both your method and class definitions require a slew of keywords to prefix them, because the defaults are not useful in this context.
On accessors, I think a lot of that problem is groupthink. "We do it that way because that's the way we do it" is the mindset. Unfortunately, this has been reinforced by various frameworks, toolkits, standards and other accessories.
There are two approaches I have seen in Python, Perl and LISP that are kind of cool (though please don't misconstrue this to be saying that these languages don't have other problems worthy of critique).
One is to overload the accessors, naming the accessor the same as the variable it accesses, and if you call it with an argument, it sets it and returns same; calling it without an argument returns the current value. As an example, if you have a variable 'foo', then instance_variable.foo() would return whatever is currently the value of foo, and instance_variable.foo('bar') would set the value of foo in that instance to 'bar' and also return 'bar' (unless it ends up being massaged by the accessor).
The other is to use a general accessor, often named param() or property() or something the like. It takes one or two arguments; if one, it is the name of the variable to be accessed; if two, the second argument is a value to set. Otherwise, it works the same as in the first approach.
Common LISP (using CLOS) very strongly encourages the first approach, because all you have to do to create a very basic accessor (i.e. one that does not massage or validate) is say that it exists, and it does. You only need to write code for it if you need to do something specific in terms of validation or formatting.
In the end, I am not surprised that Java code is mostly fluff. This stems from a failure of the language to have sane defaults. The good news is that the IDE can write a lot of that for you, but if the IDE can write it, the question remains: why does it need to be written at all?