When comparing Java vs C#, the Slant community recommends C# for most people. In the question“What is the best programming language to learn first?” C# is ranked 7th while Java is ranked 23rd. The most important reason people chose C# is:
C# runs on top of the .NET framework, which provides many libraries containing classes used for common tasks such as connecting to the Internet, displaying a window or editing files. Unlike many other languages, you don't have to pick between a handful of libraries for every small task you want to do.
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Consistent programming standards
Most Java code follows very standardized coding styles. This means that when you're starting out, there are fewer questions about how you should implement something as the programming styles and patterns are well established and consistent. This consistent style means that it's often easier to follow others' example code, and that it's more likely to meet at least a certain minimum standard of quality. This discipline with consistent stylistic standards also becomes useful later, when collaborating on projects with larger teams.
Pro Massive amount of libraries and APIs
Java has been around for such a long time that there have been tens of thousands of APIs and libraries written for almost anything you want to do.
Pro Most commonly used language in industry
Java is one of the most popular languages in industry, consistently ranking either first, or occasionally second (behind C or Javascript) in terms of usage. Polls (see sources below) show it to be consistently in high demand, particularly as measured by job board postings. This makes Java a great time investment, as you will be easily able to get a job utilizing your skills, particularly as those Java applications in production now will continue to need maintenance in the future. It also results in great support for tools and plenty of computer science books, example projects and online tutorials.
Pro Fantastic IDEs
Because Java is statically typed, integrated development environments (IDEs) for Java can provide a lot more feedback on errors you will encounter. Java IDEs can give you specific errors in the location where they occur without having to run the code every time. This makes is faster to debug and learn from your mistakes.
IDEs also have extensive auto complete capabilities that can help you learn the programming libraries you are using faster and tell you what functions are available.
Pro Introduces you to object oriented languages
Object Oriented Programming (OOP) is a paradigm that teaches you to split your problem into simpler modules with few connections between them; it's the most common paradigm used in industry. Java is the best choice as an introduction to object oriented languages because, as a statically-typed OOP-only language, it very clearly highlights core OOP principles such as encapsulation, access control, data abstraction, and inheritance.
While a scripting language provides more flexibility and terseness, learning a scripting language first would not instill these fundamental concepts as well, as they tend to obscure details such as how types work, and are less encouraging of an object oriented style.
Pro Best introduction to "C style" languages
The Java syntax is very similar to other C style languages. Learning the fundamentals of Java will port over well to other languages so you can apply what you've leaned to other languages afterwards.
Pro Platform Independent
Because of the Java Virtual Machine, the Java programming language is supported wherever a JVM is installed.
Pro You know what you do, and still simple
Because everything is typed and there is no silent cast or fail, you exactly know what you are manipulating, and there's no magic.
Have you ever watched a beginner struggling with a "couldn't call method x on y" in python or Javascript? These languages don't teach you what proper types are.
Java is one of the simplest languages to learn these basic concepts you find in every programming language.
Pro .NET is a great toolbox
C# runs on top of the .NET framework, which provides many libraries containing classes used for common tasks such as connecting to the Internet, displaying a window or editing files. Unlike many other languages, you don't have to pick between a handful of libraries for every small task you want to do.

Pro Incredibly Well-Engineered Language
Where other languages invoke the feeling of being a product of organic growth over time, C# just feels like an incredibly well-designed language where everything has its purpose and almost nothing is non-essential.
Pro Awesome IDE for Windows
On Windows, Visual Studio is the recommended C# IDE. It provides a very flexible GUI that you can rearrange the way you want and many useful features such as refactorings (rename a variable, extract some code into a method, ...) and code formatting (you can pick exactly how you want the code to be formatted).
Visual Studio also highlights your errors when you compile, making your debug sessions more efficient since you don't have to run the code to see the mistakes. There's also a powerful debugger that allows you to execute the code step-by-step and even change what part of the code will be executed next. In addition to giving you all the line-by-line information you'll need in a hassle-free manner, Visual Studio has stuff you can click on in the errors window that will take you to the documentation for that error, saving you several minutes of web searching.
In addition to all of this, Visual Studio has an intuitive, intelligent, and helpful graphical user interface designer that generates code for you (the best of WYSIWYG, in my opinion), which is helpful for new programmers. Being able to create a fantastic-looking UI with one's mouse and then optionally tweak with code helps make programming fun for beginner developers.
Visual Studio also has the best code completion --Intellisense is every bit as intelligent as the name says it is. It, as well as VS's parameter hinting, is context-, type-, user-, and position-sensitive, and displays relevant completions in a perfectly convenient yet understandable order. This feature allows a new programmer to answer the questions "What does this do?" and "How do I use it?" right then and there rather than having to switch to a browser to read through extensive documentation. This allows the programmer to satisfy their curiosity before it is snuffed out by several minutes of struggling through exhaustive documentation.
And for the more adventurous and text-ready developer, Microsoft does the best job of ensuring that everything, from interfaces and wildcard types down to Console.WriteLine("") and the + operator, is well-documented and easy to understand, with relevant and well-explained usage examples that manage to be bite-size yet complete, simple yet truly helpful. The reference site is easy to navigate, well-organized, clean and uncluttered, up-to-date, and fresh and enjoyable to look at, and every page is well-written with consideration for readers who are not C# experts yet want to read about changing the console background color.
The best part? It's free! Visual C# Express contains all of the features described above, at zero cost. If you are a student, you can probably get Visual Studio Professional from your university, which also includes tools for unit testing and supports plugins.

Pro Supports some functional features
C# is primarily object-oriented, but it also supports some features typically found in functional languages such as lambdas, delegates and anonymous classes. Methods can be treated like any other object, and the Linq query system operates on monads with lazy evaluation (though it hides this with a lot of syntactic sugar).
You don't need to use these features to code in C#, though, so you can start with OOP and then learn about them.
Pro Great introduction to object-oriented programming
Object-oriented programming is the most widely-used paradigm. C# offers support for common OOP features such as classes, methods and fields, plus some features not found in competing languages like properties, events and static classes.
C# code is much more readable thanks to the syntactic sugar it offers. You can truly concentrate on your code, not on the way it's implemented.
Pro Best language for Windows programs
C# is clearly the best choice for Windows programs. The .NET framework contains everything you need to build great-looking apps, without having to learn the confusing Win32 API or download a ton of external libraries. C# can also be used to build Windows 8's "modern" apps.
Pro Very high demand in the industry
C#'s been around for just the right amount of time, is regularly updated with useful additions, is versatile, easy to write & read, & has excellent tooling support. This means it is a top choice for many organizations & will remain so for the foreseeable future.
Pro Can mix high and low level programming
You can code at the high level without worrying about pointers and memory management, but if you so choose you can switch to lower level programming with direct memory management and pointer manipulation (though you need to compile to specifically allow this).
Pro Awesome IDE for cross-platform development
Visual studio has embraced cross platform development over the past 3 years. With Visual Studio Code, you now have a light, and quick IDE variant available for free as well.
Pro With ASP CORE a good language to learn
With CORE you are no longer just limited to Windows, so a language worth learning.
Pro Supported on many platforms
C# can be used for Windows apps, Linux apps, OS X apps, Windows 8 "modern" apps, websites, games, iPhone apps, Android apps, Windows Phone apps, and more.
If you want to create a cross-platform application, you can share most of the code and write one GUI for each platform.
Pro .NET truly universal
With .NET core it is a truly universal programming language which support desktop apps (Windows), Mobile apps (Xamarin), Web Apps (ASP.Core MVC). Also is perfectly fit to serverless programming for micro services. Soon it will be also support Web assembly (Blazor).
Pro Great language for Unity game engine
Unity provides a selection of programming languages depending on preference or knowledge - C#, JS, Boo and UnityScript. C# is arguably the most powerful with better syntax and stronger language structure. It allows using script files without attaching them to any game object (classes, methods inside unattached scripts that can be used at any time). There are more tutorials and information for C# than UnityScript and Visual Studio can be used to code for unity in C#. Additionally, learning C# allows using it outside of Unity as well unlike UnityScript.
Cons

Con Too verbose
- A Hello world needs package, class, static method and the actual
printf
. - Reading a line from input requires instatiating 5 objects in the right order.
- Exceptions are everywhere, particularly since all values are nullable.
- Java has a getter/setter culture, but without native syntax support.
- portable Java code lacks anonymous functions, and continues to lack good support for partial application, compensating instead with verbose design patterns, kludges like anonymous inner classes, or just inline code.
- It is statically typed without type inference, with a culture that promotes long class names.
- Poor support for sum-types and pattern matching leads to overuse of inheritance for dynamic dispatch and chains of nested conditionals
Especially for beginners, this can make reading Java code feel overwhelming; most Java courses tell students to simply copy, paste, and ignore a significant percentage of the code until they've learned enough to understand what it means.
For experienced programmers, this makes Java feel tedious, especially without an IDE, and actively discourages some solutions and some forms of abstraction.
Con Confusing mis-features
Some features in Java can be quite confusing for beginners.
Encapsulation is needlessly obfuscated with a confusing access control model. As an example, the "protected" keyword not only grants access to child classes, but to the entire package. Since small programs are written as one package, it becomes functionally equivalent to "public".
In OOP, everything is supposed to be an object, but, in Java, primitive types such as integers, booleans and characters are not, and must be handled as special cases.
Java continues to lack many high-level features, and, particularly prior to Java 7, compensated by adding confusing Java-only features, such as anonymous subclasses. Some example code is unreadable without knowing a special-case feature, libraries differ in style based on when they were released or what platform they target(e.g., Android vs. Desktop), and some solutions just aren't available on some platforms.
Con Locks you into the static OOP mindset
Overly focuses on class-based OOP to the detriment of programmer freedom or alternative paradigms that are better for various problems. Traps programmers into an always use class-based OOP mindset.
Con Half-baked generics
Type erasure means it doesn't even exist at runtime. The whole generics system is confusing for beginners.
Con Slow and heavy
Too far from the machine hardware.
Con Too much hype and useless complication
I've been developing in Java for 20 years and I love this language, I've never used a better designed one over the last 30+ years. However, starting with version 6, the number of really useful features in each release has steadily decreased. There is now too much marketing in Java's evolution and too few concern about developers' needs (the functionalities of the applications we develop haven't changed and enterprise application architecture is much simpler than 20 years ago). I'm deeply sad to say that today, learning Python is a much wiser choice.
Con Garbage collection may teach bad habits
Java is a garbage collected language and it does not force programmers to think about memory allocation and management for their programs. This is fine most of the time. However, it may cause some difficulties in adjusting to a non-GC language (such as C for example), where memory management needs to be done manually. But if good coding practices and habits are followed, this shouldn't be much of a problem.
Con Long learning curve
Con Worst-of-both-worlds static type system
It's just barely good enough to make decent IDEs, but it's not at the level of Idris or even Haskell. For large enterprise projects, the IDE support is important, but the static typing in Java just gets in the way for the smaller projects beginners would start with.
Python is duck typed and this makes small programs easy to develop quickly, but the price is that you have to write unit tests to avoid breaking larger programs. In contrast, you can be reasonably certain that a program that actually compiles in Idris does what you want, because assertions are built into the powerful type system. Java can't make that claim and still requires unit tests. Java has the worst of both worlds because of its poor static type system.
Con Static typing but no type inference
The type system gets in your way more than it helps. Heavy IDE support is absolutely required for reasonable productivity. This means beginners have to learn not just the language, but eventually a complex, heavyweight IDE too.
Con Lacks modern features
Java evolves very slowly - lambda expressions weren't available until Java 8 (which is not available on Android), and despite getters/setters being a long-time convention, the language still doesn't have native accessor syntax (a la C#'s properties). It's unlikely newer, popular features like list comprehensions or disjoint union types will be available anytime soon. While not strictly required for novice programmers, these make problems more complicated and tedious than they need to be - for example, when a simple local function would do, (portable) Java demands anonymous inner classes, an interface and a class, or worse, no abstraction at all.
Con Anything java can do, C# does better and more elegant.
Since C# came later, it could avoid the blatant mistakes made in Java.
Con Enforces some misguided principles
Java utilizes principles that primarily organize code into "classes" as the central concept, instead of more familiar organizational methods.
Con Checked exceptions
Checked exceptions add significantly to the cognitive load of the beginner. The more rules unrelated to the actual task that you pile onto the beginner, the slower he gets. Exponentially. And for what? Sure, they look good on paper, but checked exceptions are useless in the real world. They don't scale.
When you're calling APIs five levels deep and your method's throws clause balloons to 80 exceptions you might see, it gets kind of ridiculous. So you just say throws Exception
, which defeats the whole feature, but is more pointless boilerplate in an already tediously verbose language.
Or worse, while developing you can't be bothered and just catch{}
and silently swallow them all. Then you forget about it. Now you don't even have exceptions. The cure is worse than the disease!
So the wiser Java programmers will wrap all checked exceptions into a runtime exception, effectively making exceptions unchecked. That's at the cost of more boilerplate, but it's the lesser of evils. Unfortunately, Java doesn't even have macros to do this part for you. Maybe your IDE can write code templates for you, but that doesn't make it any easier to read.

Con Older versions lacks standard-library support for immutable data structures

Con Complex syntax
Too many syntactic constructs to learn before it becomes usable.
Con .NET is a mess
Continual drama with standards, updates, Microsoft, and being really cross-platform.
Con Excessively class based OOP oriented
Limits users into overly using awkward paradigm and creating another kind of spaghetti code.
Con A pale imitation of Java
C# is a Java-like language, but Microsoft failed to imitate Java's consistency. For instance, C# has types that cannot be passed by address (e.g. DateTime), forcing the developer to use ugly workarounds.
Con Too easy to write multithreading apps that are buggy
Many web frameworks or GUI libraries will push novice users to writing multithreaded code, which leads to frustrating race condition bugs.
Other languages with multithreading push users towards safe constructs, like passing messages and immutable or synchronized containers. But in C# the data structures aren't synchronized by default, and it's too easy to just set a field and observe the result from another thread (until you compile with Release, and now you have a heisenbug).
Con Often-used products in most C# development environments get expensive
The majority of the C# development community uses Microsoft products which are not all free and open-source. As you get into the enterprise level of some of these products and subscriptions, the expense is multiple factors of 10 greater.
While you can use a fully open-source and free C# environment, the community around that is much smaller. While this can be said for other languages as well, the majority of C# falls into the for-pay Microsoft realm.
Con Popularly used on Visual Studio (proprietary)
Most people learn and depend on Visual Studio (proprietary) to write C#. The result is people learn how to use an IDE and not the concepts or fundamentals of good programming. However, you don't need VS to develop in C#, all you need is the dotnet CLI and a text editor that supports OmniSharp like VSCodium, Vim and Emacs.
Con Large Library and eco system makes it unsuitable for beginers
yes, all the information about the .net framework is in one place, but it is so extense that it introduces a steep learning curve for newcomers to the field of programming languages.
