DEV Community: Mohd Helmi Aziz

Java Cheat Sheet

Mohd Helmi Aziz — Tue, 23 Sep 2025 06:23:51 +0000

1. BASICS:

// Package declaration (optional)
package mypackage;

// Import statements
import java.util.*;

// Main class
public class Main {
    public static void main(String[] args) {
        // This is a single-line comment

        /*
           Multi-line comment:
           Declaring a string variable and printing it
        */
        String greeting = "Hello, Mie!";
        System.out.println(greeting);
    }
}

2. VARIABLES & CONSTANTS:

public class Main {
    public static void main(String[] args) {
        // Explicit type
        int x = 42;
        String name = "Alice";

        // Type inference (Java 10+)
        var y = 10;
        var greeting = "Hello";

        // Multiple variables of the same type
        int a = 1, b = 2, c = 3;

        // Constants (final)
        final double Pi = 3.14159;
        final String Greeting = "Hello World";

        // Print examples
        System.out.println(x + ", " + name);
        System.out.println(y + ", " + greeting);
        System.out.println(a + ", " + b + ", " + c);
        System.out.println(Pi + ", " + Greeting);
        System.out.println(StatusOK + ", " + StatusNotFound);
    }
}

3. DATA TYPES:

public class Main {
    public static void main(String[] args) {

        // Boolean
        boolean b = true;

        // String
        String s = "Hello";

        // Integers
        byte i8 = -128;             // 8-bit
        short i16 = -32768;         // 16-bit
        int i32 = -2147483648;      // 32-bit
        long i64 = -9223372036854775808L; // 64-bit

        // Note: Java does NOT have unsigned types (except char)
        char u16 = 65535;           // 16-bit unsigned, Unicode character

        // Floating Point
        float f32 = 3.14f;           // 32-bit
        double f64 = 3.14159265359;  // 64-bit

        // Complex numbers not built-in in Java; need libraries like Apache Commons Math

        // Char (alias for Unicode code point, 16-bit unsigned)
        char r = '世';

        // Byte (8-bit signed)
        byte by = 'A';

        // Print examples
        System.out.println("Boolean: " + b);
        System.out.println("String: " + s);
        System.out.println("Integers: " + i8 + ", " + i16 + ", " + i32 + ", " + i64);
        System.out.println("Char: " + r);
        System.out.println("Byte: " + by);
        System.out.println("Floating Point: " + f32 + ", " + f64);
    }
}

4. OPERATORS:

public class Main {
    public static void main(String[] args) {

        // --- Arithmetic Operators ---
        int a = 10, b = 3;
        System.out.println(a + b); // addition → 13
        System.out.println(a - b); // subtraction → 7
        System.out.println(a * b); // multiplication → 30
        System.out.println(a / b); // division → 3
        System.out.println(a % b); // modulus → 1
        a++; // increment
        b--; // decrement

        // --- Relational (Comparison) Operators ---
        System.out.println(a == b); // equal to
        System.out.println(a != b); // not equal to
        System.out.println(a > b);  // greater than
        System.out.println(a < b);  // less than
        System.out.println(a >= b); // greater or equal
        System.out.println(a <= b); // less or equal

        // --- Logical Operators ---
        boolean x = true, y = false;
        System.out.println(x && y); // AND → false
        System.out.println(x || y); // OR → true
        System.out.println(!x);     // NOT → false

        // --- Bitwise Operators ---
        int m = 6, n = 3;           // 6 = 110, 3 = 011
        System.out.println(m & n);   // AND → 2
        System.out.println(m | n);   // OR → 7
        System.out.println(m ^ n);   // XOR → 5
        System.out.println(~m);      // NOT → -7
        System.out.println(m << 1);  // left shift → 12
        System.out.println(m >> 1);  // right shift → 3
        System.out.println(m >>> 1); // unsigned right shift → 3

        // --- Assignment Operators ---
        int c = 5;
        c += 3; // c = 8
        c -= 2; // c = 6
        c *= 4; // c = 24
        c /= 6; // c = 4
        c %= 3; // c = 1
        System.out.println(c);

        // --- Other Operators ---
        int max = (a > b) ? a : b; // ternary operator
        System.out.println(max);

        String str = "Hello";
        boolean check = str instanceof String; // type check
        System.out.println(check); // true
    }
}

5. CONTROL STRUCTURES:

public class Main {
    public static void main(String[] args) {

        // --- If / Else ---
        int x = 10;
        if (x > 5) {                         // if condition
            System.out.println("x > 5");
        } else if (x == 5) {                  // else-if condition
            System.out.println("x == 5");
        } else {                              // else
            System.out.println("x < 5");
        }

        // --- Switch ---
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;                        // break to prevent fall-through
            case 2:
            case 3:
                System.out.println("Tue or Wed");
                break;
            default:
                System.out.println("Other day");
        }

        // Expression-less switch alternative: use if-else
        int num = 15;
        if (num % 2 == 0) {
            System.out.println("Even");
        } else {
            System.out.println("Odd");
        }

        // --- Classic For Loop ---
        for (int i = 0; i < 3; i++) {         // initialize; condition; increment
            System.out.println(i);
        }

        // --- While Loop ---
        int j = 0;
        while (j < 3) {                       // condition
            System.out.println(j);
            j++;                               // increment inside loop
        }

        // --- Do-While Loop ---
        int k = 0;
        do {
            System.out.println(k);
            k++;
        } while (k < 3);                     // check condition after loop

        // --- Infinite Loop ---
        // for (;;) { System.out.println("loop"); } // runs forever

        // --- For-each Loop (like Go range) ---
        int[] nums = {10, 20, 30};           // array
        for (int val : nums) {               // for-each iteration
            System.out.println(val);
        }

        java.util.Map<String, Integer> map = java.util.Map.of("a", 1, "b", 2); // map
        for (java.util.Map.Entry<String, Integer> entry : map.entrySet()) {   // iterate map
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        String str = "Java";                  // string iteration
        for (int i = 0; i < str.length(); i++) {
            char r = str.charAt(i);          // get character at index
            System.out.println(i + ":" + r);
        }

        // --- Break / Continue ---
        for (int i = 0; i < 5; i++) {
            if (i == 2) continue;            // skip current iteration
            if (i == 4) break;               // exit loop
            System.out.println(i);
        }
    }
}

6. COLLECTIONS:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {

        // --- Array ---
        // Fixed size, elements of the same type
        int[] arr = {1, 2, 3};             // create array
        System.out.println(arr[0]);        // access element → 1

        // --- ArrayList ---
        // Dynamic size, elements of the same type
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");                  // add element
        list.add("Python");
        list.add("C++");
        list.add("Rust");
        System.out.println(list.get(0));   // access element → "Java"

        // --- HashMap ---
        // Key-value pairs (unordered)
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        System.out.println(map.get("Alice")); // access value → 25

        // --- Iteration examples ---

        // Array
        for (int val : arr) {
            System.out.println(val);
        }

        // ArrayList
        for (String val : list) {
            System.out.println(val);
        }

        // HashMap
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

7. METHODS:

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {

    public static void main(String[] args) {

        // --- Basic method ---
        int sum = add(3, 5);               // call method
        System.out.println(sum);           // 8

        // --- Multiple return values (simulated using array) ---
        int[] result = divide(10, 3);     // returns quotient and remainder
        System.out.println("Quotient: " + result[0] + ", Remainder: " + result[1]); // 3, 1

        // --- Variadic method ---
        int total = sumAll(1, 2, 3, 4);   // pass multiple arguments
        System.out.println(total);        // 10

        // --- Method as value (using functional interface) ---
        BiFunction<Integer, Integer, Integer> f = Main::add; // reference to method
        int res = f.apply(10, 20);
        System.out.println(res);          // 30

        // --- Anonymous function / Lambda ---
        Function<String, String> greet = (name) -> "Hello " + name;
        String msg = greet.apply("Java");
        System.out.println(msg);          // Hello Java
    }

    // Basic method
    static int add(int a, int b) {
        return a + b;
    }

    // Simulate multiple return values using array
    static int[] divide(int a, int b) {
        int q = a / b;
        int r = a % b;
        return new int[]{q, r};
    }

    // Variadic method
    static int sumAll(int... nums) {
        int total = 0;
        for (int n : nums) {
            total += n;
        }
        return total;
    }
}

Rust Cheat Sheet

Mohd Helmi Aziz — Sun, 21 Sep 2025 10:47:04 +0000

1. SETUP:

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Check version
rustc --version

# Create new project
cargo new my_project
cd my_project

# Build and run
cargo build
cargo run

2. BASICS:

fn main() {
    println!("Hello, world!"); // Print
    let x = 5;                  // Immutable variable
    let mut y = 10;             // Mutable variable
    const PI: f64 = 3.1415;     // Constant
}

3. DATA TYPES:

// Scalar
let a: i32 = -42;
let b: u32 = 42;
let c: f64 = 3.14;
let d: bool = true;
let e: char = 'R';

// Compound
let tup: (i32, f64, char) = (500, 6.4, 'z');
let (x, y, z) = tup; // Destructuring

let arr = [1, 2, 3, 4, 5];
let slice: &[i32] = &arr[1..3];

4. CONTROL FLOW:

if x > 5 {
    println!("Greater!");
} else {
    println!("Smaller!");
}

for n in 1..5 {   // 1 to 4
    println!("{}", n);
}

let mut counter = 0;
while counter < 3 {
    println!("count = {}", counter);
    counter += 1;
}

5. FUNCTIONS:

fn add(a: i32, b: i32) -> i32 {
    a + b // last expression = return
}

fn main() {
    println!("{}", add(5, 3));
}

6. OWNERSHIP & BORROWING:

fn main() {
    let s = String::from("Hello");
    takes_ownership(s); // moved
    // println!("{}", s); // ❌ cannot use after move

    let x = 5;
    makes_copy(x); // i32 implements Copy
    println!("{}", x); // ✅ still valid

    let s2 = String::from("Hi");
    borrow(&s2); // pass by reference
    println!("{}", s2); // ✅ still valid
}

fn takes_ownership(s: String) {
    println!("{}", s);
}

fn makes_copy(x: i32) {
    println!("{}", x);
}

fn borrow(s: &String) {
    println!("{}", s);
}

7. STRUCTS & ENUMS:

struct User {
    name: String,
    age: u8,
}

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn main() {
    let user = User { name: String::from("Alice"), age: 25 };
    println!("{} is {}", user.name, user.age);

    let dir = Direction::Left;
    match dir {
        Direction::Up => println!("Up"),
        Direction::Down => println!("Down"),
        Direction::Left => println!("Left"),
        Direction::Right => println!("Right"),
    }
}

8. TRAITS & IMPL:

trait Greet {
    fn say_hello(&self);
}

struct Person {
    name: String,
}

impl Greet for Person {
    fn say_hello(&self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    let p = Person { name: String::from("Bob") };
    p.say_hello();
}

9. ERROR HANDLING:

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("Division by zero!"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Ok(res) => println!("Result: {}", res),
        Err(err) => println!("Error: {}", err),
    }
}

10. COLLECTIONS:

// Vector
let mut v = vec![1, 2, 3];
v.push(4);
for i in &v {
    println!("{}", i);
}

// HashMap
use std::collections::HashMap;
let mut scores = HashMap::new();
scores.insert("Alice", 10);
scores.insert("Bob", 20);
println!("{:?}", scores);

11. COMMON MACROS:

println!("Hello {}!", "Rust"); // Print with formatting
dbg!(42); // Debug print to stderr
vec![1, 2, 3]; // Create vector

12. LIFETIMES (BASIC):

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() { a } else { b }
}

fn main() {
    let x = String::from("abcd");
    let y = "xyz";
    println!("{}", longest(&x, y));
}

13. CARGO COMMANDS:

cargo new project_name   # Create new project
cargo build              # Build project
cargo run                # Run project
cargo check              # Check for errors
cargo test               # Run tests
cargo fmt                # Format code
cargo doc --open         # Generate docs

Golang Cheat Sheet

Mohd Helmi Aziz — Sat, 20 Sep 2025 17:30:19 +0000

1. BASICS:

package main

import "fmt"

func main() {
    // This is single-line comment
    /*
       Multi-line comment: Declaring string variable
    */
    var greeting string = "Hello, Mie!"
    fmt.Println(greeting)
}

package main → entry point of the program
import → bring in packages (like fmt for printing)
func main() → starting point where execution begins

2. VARIABLES & CONSTANTS:

// Explicit type
var x int = 42
var name string = "Alice"

// Type inference
var y = 10
var greeting = "Hello"

// Shorthand (inside functions only)
z := 5
msg := "Hi"

// Multiple variables
var a, b, c int = 1, 2, 3
d, e := 4, 5

// Constants
const Pi = 3.14159
const Greeting string = "Hello World"

// Multiple constants
const (
    StatusOK = 200
    StatusNotFound = 404
)

3. DATA TYPES (Basic):

// Boolean
var b bool = true

// String
var s string = "Hello"

// Integers
var i int = 42
var i8 int8 = -128
var i16 int16 = -32768
var i32 int32 = -2147483648
var i64 int64 = -9223372036854775808

// Unsigned Integers
var u uint = 42
var u8 uint8 = 255       // alias: byte
var u16 uint16 = 65535
var u32 uint32 = 4294967295
var u64 uint64 = 18446744073709551615
var up uintptr           // pointer integer type

// Floating Point
var f32 float32 = 3.14
var f64 float64 = 3.14159265359

// Complex Numbers
var c64 complex64 = complex(1, 2)    // float32 real+imag
var c128 complex128 = complex(5, -7) // float64 real+imag

// Rune (alias for int32, Unicode code point)
var r rune = '世'

// Byte (alias for uint8)
var by byte = 'A'

4. OPERATORS:

// --- Arithmetic Operators ---
a, b := 10, 3
fmt.Println(a + b) // 13 (addition)
fmt.Println(a - b) // 7  (subtraction)
fmt.Println(a * b) // 30 (multiplication)
fmt.Println(a / b) // 3  (integer division)
fmt.Println(a % b) // 1  (modulus)

// --- Relational (Comparison) Operators ---
fmt.Println(a == b) // false
fmt.Println(a != b) // true
fmt.Println(a > b)  // true
fmt.Println(a < b)  // false
fmt.Println(a >= b) // true
fmt.Println(a <= b) // false

// --- Logical Operators ---
x, y := true, false
fmt.Println(x && y) // false (AND)
fmt.Println(x || y) // true  (OR)
fmt.Println(!x)     // false (NOT)

// --- Bitwise Operators ---
m, n := 6, 3         // 6 = 110, 3 = 011 in binary
fmt.Println(m & n)   // 2 (AND: 110 & 011 = 010)
fmt.Println(m | n)   // 7 (OR:  110 | 011 = 111)
fmt.Println(m ^ n)   // 5 (XOR: 110 ^ 011 = 101)
fmt.Println(m << 1)  // 12 (Left shift: 110 << 1 = 1100)
fmt.Println(m >> 1)  // 3  (Right shift: 110 >> 1 = 011)

// --- Assignment Operators ---
c := 5
c += 3  // c = c + 3 → 8
c -= 2  // c = c - 2 → 6
c *= 4  // c = c * 4 → 24
c /= 6  // c = c / 6 → 4
c %= 3  // c = c % 3 → 1

// --- Other Operators ---
// Address-of & Pointer Dereference
val := 42
ptr := &val        // address-of
fmt.Println(*ptr)  // dereference → 42

5. POINTERS:

// Variable declaration
x := 42
p := &x        // pointer to x
*p = 100       // change x through pointer

// Function parameter (pass by reference)
func setTo200(n *int) {
    *n = 200
}
setTo200(&x)   // x becomes 200

// Function return (return pointer)
func createPointer() *int {
    v := 300
    return &v
}
ptr := createPointer()
fmt.Println(*ptr) // 300

6. CONTROL STRUCTURES:

// --- If / Else ---
x := 10
if x > 5 {
    fmt.Println("x > 5")
} else if x == 5 {
    fmt.Println("x == 5")
} else {
    fmt.Println("x < 5")
}

// --- Switch ---
day := 3
switch day {
case 1:
    fmt.Println("Monday")
case 2, 3:
    fmt.Println("Tue or Wed")
default:
    fmt.Println("Other day")
}

// Expression-less switch
num := 15
switch {
case num%2 == 0:
    fmt.Println("Even")
default:
    fmt.Println("Odd")
}

// --- For Loops ---
// Classic
for i := 0; i < 3; i++ {
    fmt.Println(i)
}

// While-style
j := 0
for j < 3 {
    fmt.Println(j)
    j++
}

// Infinite loop
// for { fmt.Println("loop") }

// --- Range ---
// Slice
nums := []int{10, 20, 30}
for idx, val := range nums {
    fmt.Println(idx, val)
}

// Map
m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Println(k, v)
}

// String (runes)
for i, r := range "Go" {
    fmt.Printf("%d:%c\n", i, r)
}

// --- Break / Continue ---
for i := 0; i < 5; i++ {
    if i == 2 { continue }
    if i == 4 { break }
    fmt.Println(i)
}

7. COLLECTIONS:

// --- Array ---
// Fixed size, elements of the same type
var arr [3]int = [3]int{1, 2, 3}
fmt.Println(arr[0]) // 1

// --- Slice ---
// Dynamic size, built on arrays (commonly used)
var sl []string = []string{"Go", "Rust", "Python"}
sl = append(sl, "JavaScript")
fmt.Println(sl[0]) // "Go"

// --- Map ---
// Key-value pairs (unordered)
var m map[string]int = map[string]int{"Alice": 25, "Bob": 30}
fmt.Println(m["Alice"]) // 25

8. FUNCTIONS:

// Basic function
func add(a int, b int) int {
    return a + b
}
sum := add(3, 5) // 8

// Multiple return values
func divide(a, b int) (int, int) {
    q := a / b
    r := a % b
    return q, r
}
q, r := divide(10, 3) // q=3, r=1

// Named return values
func rectStats(w, h int) (area int, perimeter int) {
    area = w * h
    perimeter = 2 * (w + h)
    return
}
a, p := rectStats(4, 5) // area=20, perimeter=18

// Variadic function
func sumAll(nums ...int) int {
    total := 0
    for _, v := range nums {
        total += v
    }
    return total
}
total := sumAll(1, 2, 3, 4) // 10

// Function as value
f := add
result := f(10, 20) // 30

// Anonymous function
greet := func(name string) string {
    return "Hello " + name
}
msg := greet("Go") // Hello Go

9. STRUCTS & METHODS:

// Struct definition
type Person struct {
    Name string
    Age  int
}

// Create struct instance
p1 := Person{"Alice", 30}
p2 := Person{Name: "Bob"} // Age = 0 by default

// Access fields
fmt.Println(p1.Name) // Alice
fmt.Println(p1.Age)  // 30

// Pointer to struct
p3 := &Person{"Charlie", 25}
fmt.Println(p3.Name) // Charlie

// Method with value receiver
func (p Person) Greet() string {
    return "Hello, " + p.Name
}
msg := p1.Greet() // Hello, Alice

// Method with pointer receiver (can modify struct)
func (p *Person) HaveBirthday() {
    p.Age++
}
p1.HaveBirthday()
fmt.Println(p1.Age) // 31

// Embedding (like inheritance)
type Employee struct {
    Person
    Position string
}
e := Employee{Person{"Diana", 28}, "Engineer"}
fmt.Println(e.Name)     // Diana (from embedded Person)
fmt.Println(e.Position) // Engineer

10. INTERFACES:

// Interface definition
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Struct implementing interface
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Another struct implementing interface
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14 * c.Radius
}

// Using the interface
var s Shape

s = Rectangle{Width: 4, Height: 5}
fmt.Println(s.Area())      // 20
fmt.Println(s.Perimeter()) // 18

s = Circle{Radius: 3}
fmt.Println(s.Area())      // 28.26
fmt.Println(s.Perimeter()) // 18.84

// Empty interface (can hold any type)
var any interface{}
any = "Hello"
any = 42
any = 3.14

// Type assertion
val, ok := any.(int)
if ok {
    fmt.Println("Integer:", val)
}

// Type switch
switch v := any.(type) {
case string:
    fmt.Println("string:", v)
case int:
    fmt.Println("int:", v)
default:
    fmt.Println("unknown type")
}

11. PACKAGES AND MODULES:

// Create a new module (in project folder)
// go mod init mymodule

// Add a dependency
// go get github.com/google/uuid

// go.mod file will track module path and dependencies

// Package example
package mathutil

// Exported function (capitalized)
func Add(a, b int) int {
    return a + b
}

// Using a package
import (
    "fmt"
    "mymodule/mathutil"
)

sum := mathutil.Add(3, 5)
fmt.Println(sum) // 8

// Alias import
import m "mymodule/mathutil"
result := m.Add(2, 4)

// Blank import (import only for side effects)
// import _ "example.com/some/package"

// List all modules and versions
// go list -m all

// Tidy up dependencies
// go mod tidy

12. ERRORS AND PANIC/RECOVER:

import (
    "errors"
    "fmt"
)

// Built-in error type
err := errors.New("something went wrong")
if err != nil {
    fmt.Println(err)
}

// Functions returning error
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

// fmt.Errorf for formatted errors
name := ""
if name == "" {
    err := fmt.Errorf("invalid name: %v", name)
    fmt.Println(err)
}

// Panic: stops program immediately
// Used for unrecoverable errors
// panic("fatal error")

// Recover: used inside defer to catch panic
func safeDivide(a, b int) (result int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from:", r)
        }
    }()
    if b == 0 {
        panic("divide by zero")
    }
    return a / b
}

fmt.Println(safeDivide(10, 2)) // 5
fmt.Println(safeDivide(10, 0)) // recovered

13. CONCURRENCY (GOROUTINES, CHANNELS AND SELECT):

// Goroutine (lightweight thread)
go fmt.Println("Hello from goroutine")

// Unbuffered channel (synchronizes send/receive)
ch := make(chan int)

// Send to channel
go func() {
    ch <- 42
}()

// Receive from channel
val := <-ch
fmt.Println(val) // 42

// Buffered channel
buf := make(chan string, 2)
buf <- "A"
buf <- "B"
fmt.Println(<-buf) // A
fmt.Println(<-buf) // B

// Closing channel
close(ch)
// after close, receive gives zero value
// val, ok := <-ch (ok=false if closed)

// Select with channels
c1 := make(chan string)
c2 := make(chan string)

go func() { c1 <- "one" }()
go func() { c2 <- "two" }()

select {
case msg1 := <-c1:
    fmt.Println("Received:", msg1)
case msg2 := <-c2:
    fmt.Println("Received:", msg2)
default:
    fmt.Println("No message")
}