Valid code, but what does it mean?

[Luigi Plinge]

HashSet<Character> aset, bset = new HashSet<Character>();

bset is initialized but aset isn't - is it interpreted as something in generics?

[Paul Clapham]

It means that aset is a HashSet<Character> variable which isn't initialized, and bset is a HashSet<Character> variable which is initialized to refer to a HashSet<Character> object. It's nothing to do with generics; consider this:

String astring, bstring = "Gotcha";

[Jesper de Jong]

It is exactly the same as this:

HashSet<Character> aset;
HashSet<Character> bset = new HashSet<Character>();

I wouldn't use such a notation to declare variables in one line and initialize only one of them, because it's confusing.

[Paul Clapham]

Jesper de Jong wrote:I wouldn't use such a notation to declare variables in one line and initialize only one of them, because it's confusing.

And here we see a live example of that confusion!

[Bear Bibeault]

Indeed! Remember that just because you can do something doesn't mean that you should!

[Campbell Ritchie]

An example of what Bear says: it is possible to open a car door when travelling at 99mph. Something you can do, but don't do . . . at least not twice

[Luigi Plinge]

Would it be utterly horrible to type

        HashSet<Character> 
                aset = new HashSet<Character>(), 
                bset = new HashSet<Character>();

?

[Bear Bibeault]

To me, yeah. It's much less clear than each in their statement. Why obfuscate the code when you can make it clear?

[Luigi Plinge]

Saves typing... global RSI incidence rates must have rocketed since the introduction of Java generics...

[Bear Bibeault]

In my opinion, saving typing is never a good excuse for obfuscating code.

[Elchin Asgarli]

Bear Bibeault wrote:In my opinion, saving typing is never a good excuse for obfuscating code.

Can't agree more. Its just not comfortable later to read obfuscated code, rather than later trying to read obfuscated code, its easier to type few letters more.

[Jesper de Jong]

Luigi Plinge wrote:Saves typing... global RSI incidence rates must have rocketed since the introduction of Java generics...

You'll be pleased with one of the new features in Java 7, which will allow you to write this:

Set<Character> aset = new HashSet<>();

instead of:

Set<Character> aset = new HashSet<Character>();

[Luigi Plinge]

Good news... but I think there are still quite a few redundant characters in that code.



*runs off to start learning Groovy*