C# vs Java: Sintaks, Runtime, Generic, LINQ, dan Mana yang Dipelajari

C# dan Java adalah kerabat dekat. Keduanya adalah bahasa berorientasi objek dengan tipe statis, garbage collector, dan sintaks gaya C, keduanya di-compile menjadi bytecode untuk sebuah virtual machine, dan keduanya dipakai untuk sistem backend yang besar. C# dirilis pada 2002, sebagian sebagai jawaban Microsoft untuk Java, dan selama dua dekade keduanya saling meminjam fitur (lambda, generic, record, pattern matching). Developer yang menguasai salah satunya bisa membaca yang lain hampir seketika.

Perbedaan yang terasa sehari-hari lebih kecil dan lebih spesifik. Halaman ini membahasnya satu per satu dengan kode: potongan kode C# yang bisa kamu jalankan, dan Java di blok statis sebagai pembanding.

Sekilas

Sintaks: hampir sama

Class, method, if, for, while, switch, try/catch terbaca hampir identik. Perbedaan yang terlihat ada di konvensi penamaan dan beberapa keyword: method C# memakai PascalCase (ToUpper, WriteLine), method Java memakai camelCase (toUpperCase, println); C# menulis string dan bool, Java menulis String dan boolean; pewarisan ditulis class Dog : Animal di C# dan class Dog extends Animal di Java.

// Java
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ana");
        names.add("Ben");
        for (String n : names) {
            System.out.println(n.toUpperCase());
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben" };
        foreach (string n in names)
        {
            Console.WriteLine(n.ToUpper());
        }
    }
}

Output:

ANA
BEN

C# juga membandingkan string berdasarkan nilainya dengan ==, dan ini menghilangkan salah satu bug klasik pemula di Java: di Java, == pada dua object String membandingkan reference, jadi dua string yang sama tetapi dibuat saat runtime (dibaca dari input, hasil penggabungan) bisa dianggap tidak sama.

Property, bukan getter dan setter

Class Java mengekspos state lewat method getName() dan setName(), yang biasanya dibuat oleh IDE atau Lombok. C# punya property: member yang terbaca seperti field tetapi menjalankan kode.

// Java
public class Product {
    private double price;
    public double getPrice() { return price; }
    public void setPrice(double price) {
        if (price < 0) throw new IllegalArgumentException("negative");
        this.price = price;
    }
}

using System;

class Product
{
    public string Name { get; set; }        // auto-property

    private decimal price;
    public decimal Price                     // property with validation
    {
        get { return price; }
        set
        {
            if (value < 0) throw new ArgumentException("Price cannot be negative");
            price = value;
        }
    }
}

class Program
{
    static void Main()
    {
        var p = new Product { Name = "Mug", Price = 8.50m };
        p.Price += 1.00m;                    // reads and writes like a field
        Console.WriteLine($"{p.Name}: {p.Price:F2}");
    }
}

Output:

Mug: 9.50

Object initializer new Product { Name = ..., Price = ... } mengisi property tepat setelah object dibuat. Record di Java (Java 16) mencakup kasus data yang immutable; C# juga punya record (C# 9), ditambah property untuk semua kasus lainnya.

Tipe value: struct

Di Java, setiap tipe buatan sendiri adalah tipe reference yang disimpan di heap; hanya delapan tipe primitif (int, double, ...) yang berupa value. C# memungkinkan kamu mendefinisikan tipe value sendiri dengan struct. Struct disalin saat di-assign dan bisa disimpan langsung di dalam array dan object lain, tanpa alokasi heap terpisah.

using System;

struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y) { X = x; Y = y; }
}

class Program
{
    static void Main()
    {
        var a = new Point(1, 2);
        var b = a;          // copies the whole value
        b.X = 99;
        Console.WriteLine($"a = ({a.X}, {a.Y})");
        Console.WriteLine($"b = ({b.X}, {b.Y})");

        var grid = new Point[1000]; // one block of 1000 points, not 1000 objects
        Console.WriteLine(grid.Length);
    }
}

Output:

a = (1, 2)
b = (99, 2)
1000

Hal ini penting di game dan kode numerik, saat jutaan object kecil akan membebani garbage collector. Lihat struct.

Generic: reified vs erased

Java menghapus argumen tipe generic saat compile: saat runtime, List<Integer> hanyalah List, dan List<int> tidak diizinkan (kamu mendapat object Integer hasil boxing). C# mempertahankan argumen tipe saat runtime, jadi List<int> menyimpan int mentah dan kode bisa menanyakan apa itu T.

using System;
using System.Collections.Generic;

class Program
{
    static string Describe<T>(List<T> items)
    {
        return $"{items.Count} items of type {typeof(T).Name}";
    }

    static T Create<T>() where T : new()
    {
        return new T();     // impossible in Java: T is erased
    }

    static void Main()
    {
        Console.WriteLine(Describe(new List<int> { 1, 2, 3 }));
        Console.WriteLine(Describe(new List<string> { "a" }));

        var list = Create<List<decimal>>();
        Console.WriteLine(list.GetType().Name);
    }
}

Output:

3 items of type Int32
1 items of type String
List`1

typeof(T) dan new T() berfungsi karena runtime tahu T. Di Java, keduanya menghasilkan error compile, dan solusi yang biasa dipakai adalah mengoper object Class<T> ke mana-mana.

LINQ vs stream

Kedua bahasa punya API berantai untuk menyaring dan mengubah koleksi. Milik Java adalah Streams API (Java 8); milik C# adalah LINQ (C# 3), yang juga punya sintaks query dan bisa dipakai untuk database lewat Entity Framework.

// Java
List<String> expensive = products.stream()
    .filter(p -> p.getPrice() > 20)
    .sorted(Comparator.comparing(Product::getPrice))
    .map(Product::getName)
    .collect(Collectors.toList());

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var products = new[]
        {
            new { Name = "Lamp", Price = 35m },
            new { Name = "Pen", Price = 2m },
            new { Name = "Chair", Price = 80m },
            new { Name = "Mug", Price = 9m }
        };

        var expensive = products
            .Where(p => p.Price > 20)
            .OrderBy(p => p.Price)
            .Select(p => p.Name)
            .ToList();
        Console.WriteLine(string.Join(", ", expensive));

        var total = products.Sum(p => p.Price);
        Console.WriteLine($"Total: {total}");
    }
}

Output:

Lamp, Chair
Total: 126

Operasinya saling berpadanan satu lawan satu (filter adalah Where, map adalah Select, collect(toList()) adalah ToList()), dan versi C# tidak butuh stream() atau collector. Object new { Name = ..., Price = ... } adalah anonymous type, yang tidak punya padanan langsung di Java.

Async dan konkurensi

C# memperkenalkan async/await pada 2012: method async mengembalikan Task, dan await menghentikannya sejenak tanpa memblokir thread. JavaScript, Python, dan Rust kemudian memakai keyword yang sama. Java menempuh jalan berbeda: rangkaian CompletableFuture, dan sejak Java 21, virtual thread yang membuat kode blocking biasa menjadi murah.

// C#
async Task<string> LoadAsync(HttpClient http, string url)
{
    string body = await http.GetStringAsync(url);
    return body.Substring(0, 100);
}

// Java 21 with virtual threads: plain blocking code on a cheap thread
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> client.send(request, BodyHandlers.ofString()));
}

Kedua pendekatan bisa menangani banyak request bersamaan. C# membuat sifat asinkronnya terlihat di signature method; Java menyembunyikannya di runtime.

Exception, operator, dan perbedaan yang lebih kecil

• Checked exception. Java memaksa method mendeklarasikan atau menangkap exception tertentu (throws IOException). C# sama sekali tidak punya checked exception.
• Operator overloading. C# membuat tipe bisa mendefinisikan +, ==, <, dan kawan-kawannya, itulah sebabnya aritmetika decimal dan DateTime terbaca wajar. Java tidak bisa (BigDecimal.add).
• Virtual secara default. Method Java bisa di-override kecuali ditandai final; method C# harus ditandai virtual supaya bisa di-override, dan override-nya harus menulis override.
• Extension method. C# bisa menambahkan method ke tipe yang sudah ada ("text".IsPalindrome()); Java tidak bisa.
• Nullable value type. int? di C# adalah int yang bisa bernilai null; Java memakai Integer hasil boxing.
• Tipe unsigned. C# punya uint, ulong, ushort, dan byte yang unsigned; byte di Java bersifat signed, dan selain char 16-bit, Java tidak punya tipe integer unsigned.

Ekosistem, lowongan kerja, dan mana yang dipelajari

Ekosistem Java lebih besar di dunia server open source: Spring, Kafka, Spark, Hadoop, Elasticsearch, dan sebagian besar project Apache ditulis dengan Java. Aplikasi Android ditulis dengan Kotlin atau Java. C# punya stack yang lebih terintegrasi: satu vendor mengelola bahasa, runtime, framework web (ASP.NET Core), ORM (Entity Framework), dan IDE utamanya (Visual Studio), dan Unity menempatkannya di pusat pengembangan game.

Kedua bahasa punya pasar kerja yang besar, dan keseimbangan di antara keduanya bergantung pada wilayah dan industrinya. C# kuat di perusahaan yang dibangun di atas Microsoft dan Azure, di software keuangan dan kesehatan, dan di studio game.

Pilih C# kalau kamu ingin membuat game dengan Unity, membangun aplikasi desktop Windows, atau bekerja di perusahaan .NET. Pilih Java kalau kamu mengincar Android, big data, atau perusahaan yang backend-nya berjalan di JVM. Mana pun yang kamu pilih akan mengajarkan konsep yang kamu butuhkan untuk yang lain: class, interface, generic, koleksi, exception, dan runtime dengan garbage collector.