Switch from C# to Java, which "gotchas" I should care?

Question

I'll maybe have to switch to Java for new project. I have very few experiences about Java, because I've mainly studied and used C#, and I'm afraid of the differences between these two language/platform should likely to cause me many problems.

Which are pitfalls/gotchas I should care about?

Answer 1

I think your question is subjective. All can't be explained here. I suggest you to read Java Puzzlers, By Joshua Bloch and Neal Gafter. You can learn more and be safe from pitfalls.

Answer 2

The one that got me was Java substring args are beginIndex, endIndex while C# Subtring args are startIndex, length. Thats enough of a difference to make it annoying and a good probability of getting index out of bounds either way you switch.

Answer 3

Here are some important Java gotchas when coming from C#:

• In Java, switch cases can silently fall-through to the next, so make sure you always put break whenever appropriate. You also can't switch on String in Java.
• Generics are non-reified and parameterizable with reference types only. There is no List<int>, only a List<Integer>. Autoboxing hides the verbosity, but you can get NullPointerException when unboxing a null. Also, == and != on two boxed primitive types perform reference comparison.
  • ... because == and != on two reference types (e.g. String) are always reference comparison
  • An int can be autoboxed to an Integer; there is no autoboxing from int[] to Integer[].
• Java's byte, short, int, long are signed only. Watch for unintended sign extension.
• No multidimensional arrays, only array of arrays in Java.
• Most sub* ranged query methods use inclusive lower bound and exclusive upper bound
  • String.substring(int beginIndex, int endIndex)
  • CharSequence.subSequence(int start, int end)
  • List.subList(int fromIndex, int toIndex)
  • SortedSet<E>.subSet(E fromElement, E toElement)
  • SortedMap<K,V>.subMap(K fromKey, K toKey)

See also

• Java Puzzlers: Traps, Pitfalls, and Corner Cases
  • A fun but at the same time very educational read.
  • The book also has many successors presentations available on the web, e.g:
    • 2007 Google Tech Talk video presentation
    • TS-5186: Return of the Puzzlers: Schlock and Awe
    • TS-1188: The Continuing Adventures of Java Puzzlers: Tiger Traps
    • TS-2707: Java Puzzlers, Episode VI: The PhantomReference Menace, Attack of the Clone, Revenge of the Shift
• Wikipedia/Comparison of Java and C Sharp

Related questions

On some topics listed above:

• James Gosling’s explanation of why Java’s byte is signed
• Java noob: generics over objects only? (yes, unfortunately)
• Switch Statement With Strings in Java?
• Are upper bounds of indexed ranges always assumed to be exclusive?
• Is it guaranteed that new Integer(i) == i in Java? (YES!)
• When comparing two Integers in Java (with ==/!=) does auto-unboxing occur? (NO!)
• Why does int num = Integer.getInteger("123") throw NullPointerException? (!!!)

On general Java gotchas:

• Java - Common Gotchas
• What are the pitfalls of a Java noob?
• Most awkward/misleading method in Java Base API ?

Answer 4

depends on what kind of program you are working on. Wikipedia has this article and it's quite extensive. (also check out the "external links" section at the end) http://en.wikipedia.org/wiki/Comparison_of_Java_and_C_Sharp.

Also, I read this article when I switched from C# to Java http://www.25hoursaday.com/CsharpVsJava.html and it was very useful.

Answer 5

One obvious pitfall is comparing strings with C# style string1 == string2 (Java compares only references) instead of Java style string1.equals(string2).

Another one is that private is the default access modifier in C#, package in Java.

Also ToString() methods are not automatically localized by current culture in Java.

Answer 6

• You get no LINQ
• You get no good - looking UI (no WPF)
• No properties
• You get dancing Egyptians
• You get APIs without examples and good documentation

Hm.

Answer 7

Beware the differences in default access modifiers. Also note that all non-static methods in Java are virtual (unless you mark them as final).

Although it's somewhat out of date, I've found this to be a great reference.

Comparison of C# and Java, by Dare Obasanjo

Answer 8

I think this blog covers a lot of things that you are looking for.. http://www.ericsink.com/entries/java_eclipse_2.html

Answer 9

The biggest meta-pitfall is to assume that the Java language and libraries behave the same as similar-looking stuff in C#. Do the tutorials, read the javadocs, don't assume ...

Another meta-pitfall is to assume that the fact that you can do something in Java equally as easily/nicely as you can/could in C#. It is not true. Java is a much older language, and mistakes were made ...

And the last meta-pitfall is to think that complaining about stuff being missing / different in Java on SO will get you universally sympathetic / supportive responses!

Answer 10

• Java enums are way more powerful/complicated, they are in fact real classes instead of named integers.
• inner classes in java are more powerful (and they behave different)
• no delegates, only functional objects
• the constructor chaining thingy has a completely different syntax in both languages, i tend to fail every time i have to do that in c#
• Java has extends for subclassing and implements for interfaces, which is quite nice. C# instead relays on a naming convention which says that interfaces begin with an uppercase I in their name. I dont like that convention, since i can never be sure if someone else fails.
• java autoboxing can bite you in the a**
• java type erasure does really make things more complicated

Answer 11

In Java language the objective equivalents of primitive types such as int, char, are not "value types" (e.g. Integer is a reference type). In C# the System.Int32 is a structure.

Answer 12

I think this is a great article that summarizes the differences.