Language Fundamentals

byte flags = 0b0000_0110;     // binary literal (Java 7+)
int port = 0x1F90;            // hex
long nanos = 1_500_000_000L;  // underscores for readability
float ratio = .5f;            // f suffix required
double pi = 3.141592653589793;
char newline = '\n';
boolean enabled = true;

// Source you write:
List<Integer> scores = List.of(90, 85, 88);
int top = scores.get(0);

// Compiler conceptually inserts:
// List.of(Integer.valueOf(90), ...)
// top = scores.get(0).intValue();

public class OrderService {
    private static final Logger LOG = LoggerFactory.getLogger(OrderService.class);
    private final OrderRepository repo;  // must set in constructor

    private int processedCount;          // instance, defaults to 0

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

    public void handle(Order order) {
        final String id = order.id();    // local final — cannot reassign
        int retries = 0;                 // local
        if (id == null) {
            return;                      // block scope ends — locals discarded
        }
        while (retries < 3) {
            retries++;
        }
    }
}

int a = 10, b = 3;
int q = a / b;              // 3, not 3.333...
double exact = (double) a / b; // 3.333... — cast before divide

int x = 5;
int post = x++;  // post: returns 5, then x is 6
int pre = ++x;   // pre: x becomes 7, returns 7

final int READ = 1 << 0;   // 0001
final int WRITE = 1 << 1;  // 0010
int perms = READ | WRITE;
boolean canRead = (perms & READ) != 0;

String level = score >= 60 ? "pass" : "fail";

// Pattern matching instanceof (Java 16+)
if (obj instanceof String s) {
    System.out.println(s.length());  // s scoped to true branch
}

// Old style — still valid
if (obj instanceof String) {
    String s = (String) obj;  // extra cast
}

if (user == null) {
    throw new IllegalArgumentException("user required");
} else if (!user.isActive()) {
    log.warn("inactive {}", user.id());
} else {
    processActiveUser(user);
}

// DON'T — missing break causes fall-through
switch (day) {
    case MONDAY:
        log.info("start week");
        // falls into TUESDAY without break!
    case TUESDAY:
        log.info("tuesday");
        break;
    default:
        log.info("other");
}

switch (day) {
    case MONDAY, FRIDAY -> log.info("busy");
    case SATURDAY, SUNDAY -> log.info("weekend");
    default -> log.info("midweek");
}

// Switch expression — produces a value
String badge = switch (status) {
    case OK -> "green";
    case WARN -> "amber";
    case ERROR -> "red";
    default -> "gray";
};

// Multi-line branch needs yield (not return)
String msg = switch (code) {
    case 404 -> {
        log.warn("missing");
        yield "Not found";
    }
    default -> "Error " + code;
};

for (int i = 0; i < items.size(); i++) {
    process(items.get(i));
}

for (var line : Files.readAllLines(path)) {
    if (line.isBlank()) continue;  // skip to next iteration
    parse(line);
}

outer:
for (int r = 0; r < matrix.length; r++) {
    for (int c = 0; c < matrix[r].length; c++) {
        if (matrix[r][c] == target) break outer;
    }
}

int n = 0;
do {
    n = readSensor();
} while (n == 0);

int[] primes = { 2, 3, 5, 7 };           // array literal
int[] buf = new int[1024];                  // default: all 0
String[] names = new String[] { "a", "b" }; // redundant [] on right side optional

// Multidimensional — array of arrays (jagged allowed)
int[][] matrix = {
    { 1, 2, 3 },
    { 4, 5 },
    { 6, 7, 8, 9 }
};
int rows = matrix.length;      // 3
int colsRow0 = matrix[0].length; // 3

int[] src = { 1, 2, 3, 4, 5 };
int[] dst = Arrays.copyOf(src, src.length);
int[] grown = Arrays.copyOf(src, 10);  // last 5 elements are 0

int[] manual = new int[src.length];
System.arraycopy(src, 0, manual, 0, src.length);

// Compare content, not references
boolean same = Arrays.equals(src, dst);

String s = "hello";
s.toUpperCase();       // returns "HELLO" — s still "hello"
s = s.toUpperCase();   // s now references "HELLO", "hello" may be GC'd if unreferenced

String a = "transaction";     // likely pool entry at compile time
String b = "transaction";     // same reference as a
String c = new String("transaction"); // heap object (until interned)
String d = c.intern();        // add to pool if absent; return pooled reference

System.out.println(a == b);     // true — same reference
System.out.println(a == c);     // false — different objects
System.out.println(a == d);     // true after intern

// NEVER for value comparison
System.out.println(a.equals(c)); // true — always use equals for content

// O(n²) time and memory — each += copies entire string
String bad = "";
for (int i = 0; i < 50_000; i++) {
    bad += i;  // new char[] each iteration
}

// O(n) amortized — single expandable buffer
StringBuilder sb = new StringBuilder(64_000); // presize if length known
for (int i = 0; i < 50_000; i++) {
    sb.append(i);
}
String good = sb.toString();

// Java 8+ — chain without explicit builder for simple cases
String joined = String.join(",", List.of("a", "b", "c"));

"  Hello  ".strip();              // "Hello"
"  Hello  ".stripLeading().stripTrailing();
"abc".toUpperCase();                 // "ABC"
"abc".replace('b', 'B');             // "aBc" — char replace
"abc".replace("bc", "xyz");          // "axyz"
" a b ".replaceAll("\\s+", "-");    // "-a-b-" regex
" a b ".replaceFirst("\\s+", "-");   // "-a b-"

"Hi".charAt(0);           // 'H' (returns int code unit)
"Hi".codePointAt(0);        // 72 — use for supplementary chars
"Hi".getBytes(StandardCharsets.UTF_8);
"Hi".toCharArray();

"ab".concat("cd");                    // "abcd"
String.valueOf(42);                     // "42" — also overloads for primitives
"order-123".matches("order-\\d+");      // true (regex)
"line1\nline2".lines().count();         // 2
"-".repeat(5);                          // "-----"
"  x  ".indent(4);                      // add 4 spaces per line
"\\n".translateEscapes();               // actual newline char

"file.txt".compareTo("file.pdf");       // negative — lexicographic
"HTTP".compareToIgnoreCase("http");     // 0

String msg = String.format("User %s: %d orders, total $%,.2f", name, count, total);
// Locale-aware numbers/dates:
String loc = String.format(Locale.US, "%,.2f", 1234.5);

String line = "balance: %,.2f".formatted(balance);

String sql = """
                SELECT id, name
                FROM users
                WHERE active = true
                """;

String json = """
    {
      "id": %d,
      "name": "%s"
    }
    """.formatted(userId, name);

int i = 100;
long L = i;           // OK
float f = i;          // OK
double d = f;

char c = 'A';
int code = c;         // 65 — char promotes to int in arithmetic

double pi = 3.14159;
int truncated = (int) pi;    // 3 — toward zero
byte b = (byte) 300;         // 44 — overflow wraps (byte range)

long big = 9_000_000_000L;
int overflow = (int) big;    // low 32 bits — silent data loss

Object obj = "hello";
String s = (String) obj;   // OK at runtime

Object num = Integer.valueOf(42);
// String bad = (String) num;  // ClassCastException

// Safe pattern (Java 16+)
if (obj instanceof String str) {
    System.out.println(str.length());
}

var path = Path.of("/tmp", "data.csv");
var lines = Files.readAllLines(path);
var map = Map.of("key", 1, "other", 2);

// var data = {1, 2, 3};              // compile error
// var ambiguous = condition ? 1 : 1.0; // compile error — no common type

for (var i = 0; i < 10; i++) { }     // int inferred

// Good when type is obvious:
var response = httpClient.send(request, BodyHandlers.ofString());

// Spell out when it helps readers:
long rowCount = stream.count();