.NET is one product. Microsoft ships all of these parts, and versions them together:

• the runtime
• the base class library
• the web framework
• the object-relational mapper (ORM)
• the dependency injection (DI) container
• the test runner

Java is a specification plus a market. Oracle, Eclipse, Amazon, Azul and Red Hat all ship a Java Development Kit (JDK) built to the same specification. The web framework, the DI container and the ORM come from Spring or Quarkus, not from the JDK.

Each .NET piece has a Java counterpart, but the Java counterparts rarely come from the same vendor:

So a Java web service begins by choosing its framework. You list the framework as dependencies in the build file. ASP.NET Core arrives with the .NET SDK. But these dependencies are downloaded like any other library:

<!-- pom.xml: none of these ship with the JDK -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>       <!-- the ASP.NET Core role -->
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>  <!-- the EF Core role -->
</dependency>

Each <dependency> names a library by its group and its artifact. The group and the artifact are the two parts of a Maven name. spring-boot-starter-web is called a starter. It is one dependency that adds Spring's web framework and a web server. spring-boot-starter-data-jpa adds Hibernate, which is the most widely used ORM. No versions appear, because the Spring Boot parent file chooses them for you.

Java code also looks different on the page, because the C# community and the Java community chose different conventions:

Here is one interface and one class in each language, written in the style of each community:

// The namespace need not match the folder.
namespace Acme.Billing;

// Interfaces start with I, methods use PascalCase.
public interface IOrderRepository
{
    Order? FindById(long id);
}

public class OrderService(IOrderRepository repository)
{
    // Private fields use _camelCase, with a leading underscore.
    private readonly IOrderRepository _repository = repository;
}

// The package matches the folder com/acme/billing/.
package com.acme.billing;

// No I prefix, and methods use camelCase.
public interface OrderRepository {
    Order findById(long id);
}

public class OrderService {
    // Fields have no underscore.
    private final OrderRepository repository;

    public OrderService(OrderRepository repository) { this.repository = repository; }
}

The Java file starts with the line package com.acme.billing; and it is in the folder com/acme/billing/. The file name matches the public class inside the file. The interface name has no I prefix. Method names and field names start with a lower-case letter. The field name has no underscore.

Both languages made this mistake, and both catch it only while the program runs, not when it compiles:

Object[] objects = new String[2];
objects[0] = 42;         // compiles; throws ArrayStoreException at runtime

Generics are invariant to avoid exactly this problem. That is why a List<String> is not a List<Object>.

Several vendors build and ship the JDK, each from the same OpenJDK source code:

Each of these distributions passes the Technology Compatibility Kit (TCK). The TCK is the test suite that proves that a JDK behaves like Java. The differences between the distributions are support, licensing and a few extras. So do not spend a week choosing. Take Temurin.

Since Java 11, you can run a single .java file with no separate compile step. Since Java 22, such a program can have several files. Java 25 finalised compact source files and instance main methods Java 25. This feature removes the extra code that made the Java hello world program a joke:

// Program.cs
Console.WriteLine("Hello");

// dotnet run

// Hello.java
void main() {
    IO.println("Hello");
}

// java Hello.java

The whole program is the method void main(). The program has no class around the method, no String[] args and no static. IO.println writes a line, like Console.WriteLine. The feature is final in Java 25, as JEP 512, so it is safe in scripts and teaching. Most real code is still in an ordinary class with a public static void main(String[] args) method.

public class App {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

Java has no properties, so getters and setters are real methods that someone has to write. But nobody types these methods. Cmd+N generates constructors, getters, setters, equals, hashCode, toString and delegating methods. Here is a customer class in both languages:

public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class Customer {
    private String name;
    private String email;

    // Generated with Cmd+N, then Getter and Setter.
    public String getName()          { return name; }
    public void   setName(String n)  { this.name = n; }
    public String getEmail()         { return email; }
    public void   setEmail(String e) { this.email = e; }
}

getName and setName are ordinary methods that read and write a private field. IntelliJ writes them for you, but they are still code that you read and maintain. Most of that extra code disappears when the type can be a record Java 16. See Records.

Debugging works in much the same way as in Visual Studio, but under different names:

The condition of a conditional breakpoint is a Java expression. It is evaluated at the line of the breakpoint, so it can use any variable in scope:

// Right-click the breakpoint, then type the condition:
order.customer().id() == 1042 && order.lines().size() > 10

The condition is ordinary Java. == compares the customer's numeric id, and && joins the two tests. The debugger stops only when both tests are true.

In Java, a set of separate, mature tools does the same as Roslyn analyzers. You add these tools to the build. IntelliJ's own inspections are strong by default, and they do roughly the same as ReSharper. But your build server should run these tools:

Error Prone runs inside the compiler, so a bug like this one fails the build instead of reaching code review:

if (amount < 0) {
    // Error Prone reports DeadException: the exception is created but never thrown.
    new IllegalArgumentException("negative amount");
}

The line new IllegalArgumentException(...) creates an exception and then discards it, because the throw is missing. The compiler accepts the line, but Error Prone stops the build.

Java has two kinds of initialiser block. Both kinds run at predictable points. Both kinds appear in real code, particularly in older code and in static registries. In this example, a registry maps a file format to the object that handles the format. Handler is an interface that the team wrote, and JsonHandler is one implementation of Handler.

public class Registry {

    private static final Map<String, Handler> HANDLERS;

    static {
        HANDLERS = new HashMap<>();
        HANDLERS.put("json", new JsonHandler());
    }

    private final long created;

    {
        created = System.nanoTime();
    }

    public Registry() { }
}

A field initialiser runs at the same point as an instance initialiser, after super() returns. An example of a field initialiser is private String season = "winter sale";. C# runs the field initialisers of a subclass before the base constructor. So when a Java superclass constructor calls an overridden method, the method sees the fields of the subclass before they are set. For an example, see this prediction.

As in C#, every class inherits from a root class, and a class overrides a few methods of the root class. In Java, the root class is Object. The method names start with a lower-case letter. The rules about these methods are kept by convention, and the compiler does not check them. Here is Money, which is an amount in a currency. It overrides the three methods that you will write most often:

public class Money(decimal amount, string currency)
{
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;

    public override string ToString() => $"{Amount} {Currency}";
    public override bool Equals(object? o) =>
        o is Money m && Amount == m.Amount && Currency == m.Currency;
    public override int GetHashCode() => HashCode.Combine(Amount, Currency);
}

string kind = money.GetType().Name;  // "Money"

public class Money {
    private final BigDecimal amount;
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    @Override public String toString() { return amount + " " + currency; }
    @Override public boolean equals(Object o) {
        return o instanceof Money m
            && amount.equals(m.amount) && currency.equals(m.currency);
    }
    @Override public int hashCode() { return Objects.hash(amount, currency); }
}

String kind = money.getClass().getSimpleName();  // "Money"

In practice, you rarely write these three methods yourself. A record generates all three methods from its fields. See Records.

Object has three more methods that you should recognise and not call. finalize() has been deprecated for removal since Java 18. To release resources, use try-with-resources. wait() and notify() exist on every object. The closest matches in C# are Monitor.Wait and Monitor.Pulse. wait() and notify() are a 1990s API, so use java.util.concurrent. See wait, notify and notifyAll.

Imports work almost like using directives in C#, with three differences. Java imports types, not namespaces. Java has no import aliases. And Java imports nothing for the whole project.

Here are the common forms side by side:

global using System.Linq;  // every file in the project
using System.Text.RegularExpressions;  // a namespace
using static System.Math;  // a type's static members
using Rx = System.Text.RegularExpressions.Regex;

var r = new Rx("a+");
var m = Max(1, 2);

import java.util.*;  // every type in java.util
import java.util.regex.Pattern;  // one type
import static java.lang.Math.max;  // one static member

var p = Pattern.compile("a+");
int m = max(1, 2);
java.sql.Date d = null;  // no alias: a clashing name is written in full

The missing internal is a real gap, and it affects how Java libraries are designed. C# gives you an access level for the whole assembly, and InternalsVisibleTo for tests. The options in Java are weaker. The strongest option is the Java Platform Module System (JPMS). It hides whole packages, not single classes. The table lists the options:

Remember the last row. Java tests are normally in the same package as the code they test. The tests are under src/test/java, not under src/main/java. So the tests get package-private access, and they need nothing like InternalsVisibleTo. For the module system, see the chapter Modules, JPMS and the missing internal.

// in the production project
[assembly: InternalsVisibleTo("Billing.Tests")]

internal static class InvoiceNumbers { ... }   // Billing.Tests may now call it

// src/main/java/com/acme/billing/InvoiceNumbers.java
package com.acme.billing;
class InvoiceNumbers {                       // no modifier: package-private
    static String next() { ... }
}

// src/test/java/com/acme/billing/InvoiceNumbersTest.java
package com.acme.billing;                    // same package, so the test can see it
class InvoiceNumbersTest {
    @Test void startsWithInv() { assertTrue(InvoiceNumbers.next().startsWith("INV")); }
}

InvoiceNumbers has no access keyword, so only code in com.acme.billing can use it. The test is under src/test/java, but it declares the same package. So the test can call InvoiceNumbers.next() directly.

Here is the whole mapping, starting from the C# keywords that you know:

public class Account
{
    internal decimal Limit;           // any code in this assembly
    protected internal decimal Fee;   // subclasses anywhere, or any code in this assembly
    private protected decimal Rate;   // subclasses, but only those in this assembly
}

A package name is a reversed domain name, all lower-case, with no underscores. An example is com.acme.billing.api. The convention is universal, and the tools assume it. Unlike in C#, the company prefix is not decoration. It exists so that Java archive (JAR) files from different vendors never collide on the classpath.

// src/main/java/com/acme/billing/api/InvoiceController.java
package com.acme.billing.api;    // reverse domain, lowercase, and it matches the folders

The folders under src/main/java follow the package name. The folders are com/acme/billing/api, with one folder for each part of the name.

interface IProducer<out T> { T Next(); }
interface IConsumer<in T>  { void Take(T item); }

IEnumerable<object> items = new List<string>();   // allowed by IEnumerable<out T>

Action<object> print = o => Console.WriteLine(o);
Action<string> printText = print;                 // allowed by Action<in T>

Java has no variance on the declaration. Java says the same thing in the place where the type is used, with a wildcard. For example, a parameter of type List<? extends Number> accepts a List<Integer>. See Variance is at the use site.

interface ILimits
{
    const int MaxLines = 50;     // a constant
    static int Counter = 1;      // a static field, which code can reassign
}

ILimits.Counter++;               // compiles

public interface Limits {
    int MAX_LINES = 50;      // a constant, read as Limits.MAX_LINES
}

The permitted subtypes of a sealed type follow four rules:

Here a sealed interface keeps one branch closed and leaves another open:

public sealed interface Event permits UserEvent, SystemEvent { }

public final class UserEvent implements Event { }        // closed
public non-sealed class SystemEvent implements Event { } // anyone may extend this branch

UserEvent is final, so nothing may extend it. SystemEvent is non-sealed, so any class may extend it. A switch case for SystemEvent also covers those subclasses.

Varargs are the same idea as params in C#. The same rule applies, so a varargs parameter must be the last parameter:

void Log(string fmt, params object[] args) { }
Log("a {0}", 1);

void log(String fmt, Object... args) { }
log("a %s", 1);

Object... args does the same as params object[] args in C#. The caller passes any number of values, and the method receives an array. In the format string, C# writes {0}. Java writes %s.

Java has no extension methods, so a helper wraps its argument. C# code reads from left to right. Java code often reads from the inside to the outside:

var readOnly = Collections.unmodifiableList(new ArrayList<>(xs));

Collections.unmodifiableList is written first and runs last. C# would write a chain of calls here. Streams are the important exception. This is one reason why streams feel so different from the rest of the language.

public readonly record struct Money(decimal Amount)
{
    public static Money operator +(Money a, Money b) => new(a.Amount + b.Amount);
}

var total = price + shipping;     // calls the operator above

Java overloads exactly one operator, which is + for strings. Java does not let you overload any other operator. That matters most in money code. In the example below, every variable is a decimal in C# and a BigDecimal in Java:

decimal total = price * quantity + shipping;
if (total > limit) { ... }

BigDecimal total = price.multiply(quantity).add(shipping);
if (total.compareTo(limit) > 0) { ... }

BigDecimal cannot define operators, so it uses methods. The method multiply replaces *. The method add replaces +. The test compareTo(limit) > 0 replaces >. When a C# developer first writes money code in Java, this is the most common source of mistakes that produce no error. See Numbers, money and time.

C# has the keywords readonly and const. Java has one keyword, final:

private final List<String> names = new ArrayList<>();

names.add("ada");             // fine, mutating the list
names = new ArrayList<>();    // does not compile, rebinding the reference

Constants look like this in each language:

public const int MaxRetries = 3;
public static readonly TimeSpan Timeout =
    TimeSpan.FromSeconds(30);

public static final int MAX_RETRIES = 3;
public static final Duration TIMEOUT = Duration.ofSeconds(30);

Java uses static final for both const and static readonly. MAX_RETRIES is written in capitals with underscores. Constants are the one place where Java does not use camelCase. All Java code follows this rule.

Record patterns depend on records. The components of a record are part of its type, so a switch can take a record apart by position. This example uses the sealed type Payment from the chapter Interfaces, abstract classes and sealing:

String describe(Payment p) {
    return switch (p) {
        case Card(String last4) when last4.equals("0000") -> "a test card";
        case Card(String last4)                           -> "card ending " + last4;
        case BankTransfer(String iban)                    -> "transfer from " + iban;
        case Voucher(String code)                         -> "voucher " + code;
    };
}

C# can also match patterns on positional records. But C# has no equivalent of a Java sealed type. So the C# compiler cannot know that the set of cases is complete, and it warns unless you add a discard arm.

A type pattern gives you the whole object, and you then call its accessors. A record pattern Java 21 takes the record apart as it matches. It puts each component into its own variable. Here is the receipt description again, written with record patterns:

string Describe(Payment payment) => payment switch
{
    Card(var last4) => $"card ending {last4}",  // a positional pattern
    BankTransfer(var iban) => $"transfer from {iban}",
    Voucher(var code) => $"voucher {code}",
    _ => throw new ArgumentException("unknown payment")
};

String describe(Payment payment) {
    return switch (payment) {
        case Card(var last4) -> "card ending " + last4;
        case BankTransfer(var iban) -> "transfer from " + iban;
        case Voucher(var code) -> "voucher " + code;
    };
}

A record pattern can hold other record patterns. The shop sells in euros, and a price check warns about any order line that is priced in another currency. An order line holds a Money, and Money is itself a record. So one pattern can take both records apart:

if (line instanceof OrderLine(var productId, _, Money(_, var currency))
        && !currency.equals("EUR")) {
    System.out.println(productId + " is priced in " + currency);
}

C# nests positional patterns in the same way. The same test in C# is line is OrderLine(var productId, _, Money(_, var currency)).

One more kind of pattern exists, but only as a preview feature. A preview feature is finished but not yet final, and it is disabled unless you ask for it. The feature here is called Primitive types in patterns, instanceof and switch Java 25 preview. It lets a pattern test the value of a number. For example, instanceof int on a double is true only if the value converts to an int and nothing is lost.

Imagine quantities that are imported from a spreadsheet. Every number arrives as a double:

// Preview in Java 25: compile and run with --enable-preview.
double quantity = 3.0;                 // for example, read from a spreadsheet
if (quantity instanceof int whole) {   // matches: 3.0 converts to an int with no loss
    System.out.println(whole + " items");
}
boolean exact = 2.5 instanceof int;    // false: the conversion would lose the .5

This is the feature's third preview in Java 25. Do not use it in code you ship. C# has no counterpart. In C#, quantity is int whole on a double does not compile.

In the chapter Interfaces, abstract classes and sealing, a card payment cost a flat fee of 0.30. Suppose the fee changes to 1.4 percent of the order total, but never less than 0.30. The card arm now needs two steps. An arm of a C# switch expression cannot hold statements, so C# moves the steps into a method. Java puts the steps in a block that ends with yield:

decimal Fee(Payment payment, decimal total) => payment switch
{
    Card => CardFee(total),
    BankTransfer or Voucher => 0m,
    _ => throw new ArgumentException("unknown payment")
};

decimal CardFee(decimal total) => Math.Max(total * 0.014m, 0.30m);

BigDecimal fee(Payment payment, BigDecimal total) {
    return switch (payment) {
        case Card c -> {
            BigDecimal percentFee = total.multiply(new BigDecimal("0.014"));
            yield percentFee.max(new BigDecimal("0.30"));
        }
        case BankTransfer t -> BigDecimal.ZERO;
        case Voucher v -> BigDecimal.ZERO;
    };
}

IEnumerable<int> Evens(int max)
{
    for (var i = 0; i <= max; i += 2)
        yield return i;       // hand back one value, then pause here
}

foreach (var n in Evens(6)) Console.Write(n);   // 0246

Java has no goto. C# code mostly uses goto to leave nested loops. Java leaves nested loops with a labelled break. Here, orders is a List<Order>, and the scan stops at the first order line with a quantity of zero:

foreach (var order in orders)
    foreach (var line in order.Lines)
        if (line.Quantity == 0)
            goto done;
done:
Console.WriteLine("scan finished");

scan:
for (var order : orders)
    for (var line : order.lines())
        if (line.quantity() == 0)
            break scan;          // leaves both loops
System.out.println("scan finished");

The arrow form works on more types than the old switch did, but not on every type. Here is what a switch accepts:

Strings work as labels. The shop sorts uploaded product files by their extension. Here extension holds text such as "png":

String kind = switch (extension) {
    case "jpg", "png" -> "image";       // strings are compared with equals()
    case "pdf"        -> "document";
    default           -> "other";
};

Each label is compared with equals, so "png" matches any string with those three letters. It does not matter whether the two strings are the same object. With ==, it would matter.

In Java, the classes Pattern and Matcher replace the Regex class of .NET. The pattern syntax is almost the same. But Java splits the work between two objects, and every backslash is doubled. Here the shop splits a phone number such as 555-0199 into its first three digits and its last four digits. phone holds one number, and notes holds text that may contain several numbers:

var re = new Regex(@"(?<area>\d{3})-(?<num>\d{4})");

var m = re.Match(phone);
if (m.Success)
{
    var area = m.Groups["area"].Value;
}

var all = re.Matches(notes);
var hidden = re.Replace(phone, "$1-XXXX");

import java.util.regex.*;

Pattern re = Pattern.compile("(?<area>\\d{3})-(?<num>\\d{4})");

Matcher m = re.matcher(phone);
if (m.find()) {
    String area = m.group("area");
}

List<MatchResult> all = re.matcher(notes).results().toList();
String hidden = re.matcher(phone).replaceAll("$1-XXXX");

The next example shows options and the other everyday methods. A customer's note may mention product codes such as SKU-1042, typed in any mix of upper and lower case:

var sku = new Regex(@"sku-\d+",
    RegexOptions.IgnoreCase | RegexOptions.Compiled);

bool mentionsProduct = sku.IsMatch(note);
string[] pieces = sku.Split(note);  // the text between the codes

Pattern sku = Pattern.compile("sku-\\d+",
    Pattern.CASE_INSENSITIVE);  // Java has no Compiled option

boolean mentionsProduct = sku.matcher(note).find();  // not matches()
String[] pieces = sku.split(note);  // the same, but no empty last piece

Here is the full mapping from Regex in .NET:

Here are the two cases together, using the order's lines:

// A fixed number of pieces: plain + builds the string once.
String summary = "Order " + orderId + " has " + count + " lines";

// A loop: use a StringBuilder, because += would build a whole new string each time round.
var sb = new StringBuilder();
for (var line : lines) sb.append(line.productId()).append('\n');

In the loop, text += line.productId() would copy all the text built so far on every pass. So the work grows much faster than the number of lines. sb.append adds the text to the same builder, as it does in C#.

You saw a switch over OrderStatus in the chapter Switch expressions and statements. That switch needs no default, because it covers every constant. Here is the switch again, to show how the labels are written:

String label = switch (status) {
    case NEW       -> "waiting for payment";
    case PAID      -> "being packed";
    case SHIPPED   -> "on its way";
    case CANCELLED -> "cancelled";
};

The switch has four labels, from NEW to CANCELLED. The four labels cover every constant, so the switch needs no default.

An enum with one constant has exactly one object. The Java Virtual Machine (JVM) guarantees that, even when objects are saved and loaded again or created through reflection. That makes a one-constant enum the most reliable way to write a singleton in Java. Here the shop keeps one shared table of exchange rates:

public enum ExchangeRates {
    INSTANCE;

    private final Map<String, BigDecimal> rates = new ConcurrentHashMap<>();

    public void put(String currency, BigDecimal rate) { rates.put(currency, rate); }
    public BigDecimal get(String currency)             { return rates.get(currency); }
}

ExchangeRates.INSTANCE.put("USD", new BigDecimal("1.08"));

In an application that uses Spring, you would make this a bean instead. A bean is an object that Spring creates once and gives to every class that needs it. It is still useful to recognise the enum singleton in library code.

The other direction is ? super, which does the same as the in keyword in C#. This method adds test cards to any list that can hold cards:

void addTestCards(List<? super Card> target) {
    target.add(new Card("0000"));
}

List<Payment> payments = new ArrayList<>();
addTestCards(payments);   // fine: a List<Payment> can hold cards

Here are the four forms that a list type can have:

A type argument must be a class, so List<int> is not legal Java. You write List<Integer>. Each int is then wrapped in an Integer object. This wrapping is called boxing.

List<Integer> quantities = new ArrayList<>();
quantities.add(42);                        // boxed: stored as an Integer object

int[] raw = new int[1_000_000];            // one block of ints, no objects
int total = IntStream.of(raw).sum();       // a stream of plain ints: nothing is boxed

A map key is boxed in the same way. C# writes Dictionary<int, V>. Java writes Map<Integer, V>. An Integer can also be null, so it does the same as int? in C#.

Erasure removes the type argument from an object. But a compiled class still keeps the type arguments that are written in its field types, its method signatures and its superclass. Libraries such as Jackson and Spring read these type arguments to recover a full generic type. Here json holds a JSON array of customers:

// The { } creates a subclass whose superclass keeps List<Customer>.
List<Customer> customers = mapper.readValue(json, new TypeReference<List<Customer>>() { });

// Spring's version of the same trick, when calling another service.
List<Customer> body = restClient.get().uri("/customers").retrieve()
        .body(new ParameterizedTypeReference<List<Customer>>() { });