Java Data Types

public static void main(String[] args) {
    // type   name        value
    String firstName = "Folau";
    int    age       = 30;
    double salary    = 85000.50;

    System.out.println(firstName); // Folau
    System.out.println(age);       // 30
    System.out.println(salary);    // 85000.5
}

public static void main(String[] args) {
    byte minByte = -128;
    byte maxByte = 127;
    byte userAge = 25;  // Age fits easily in a byte

    System.out.println("Min byte: " + minByte);  // -128
    System.out.println("Max byte: " + maxByte);   // 127
    System.out.println("Age: " + userAge);         // 25

    // Useful for binary data
    byte[] fileData = {72, 101, 108, 108, 111};  // "Hello" in ASCII
    System.out.println(new String(fileData));      // Hello
}

public static void main(String[] args) {
    short temperature = -15;
    short elevation = 8849;   // Mount Everest height in meters
    short year = 2026;

    System.out.println("Temperature: " + temperature + "°C");  // -15°C
    System.out.println("Elevation: " + elevation + "m");        // 8849m
    System.out.println("Year: " + year);                        // 2026
}

public static void main(String[] args) {
    int population = 331000000;    // US population
    int salary = 95000;
    int itemCount = 0;

    // Common use: loop counter
    for (int i = 0; i < 5; i++) {
        itemCount++;
    }

    System.out.println("Population: " + population);  // 331000000
    System.out.println("Salary: $" + salary);          // $95000
    System.out.println("Items: " + itemCount);         // 5

    // You can use underscores for readability (Java 7+)
    int billion = 1_000_000_000;
    System.out.println("Billion: " + billion);         // 1000000000
}

public static void main(String[] args) {
    long worldPopulation = 8_000_000_000L;  // 8 billion - too large for int!
    long timestamp = System.currentTimeMillis();
    long fileSize = 5_368_709_120L;  // 5 GB in bytes
    long databaseId = 9_876_543_210L;

    System.out.println("World population: " + worldPopulation);
    System.out.println("Current timestamp: " + timestamp);
    System.out.println("File size: " + fileSize + " bytes");
    System.out.println("DB ID: " + databaseId);

    // Without the L suffix, Java treats the number as an int and you get an error
    // long wrong = 9876543210;  // COMPILE ERROR: integer number too large
    long correct = 9876543210L;  // Works because of the L suffix
}

public static void main(String[] args) {
    float pi = 3.14159f;          // Note the 'f' suffix
    float temperature = 98.6f;
    float gpa = 3.85f;
    float price = 19.99f;

    System.out.println("Pi: " + pi);              // 3.14159
    System.out.println("Temp: " + temperature);    // 98.6
    System.out.println("GPA: " + gpa);             // 3.85
    System.out.println("Price: $" + price);        // $19.99

    // Without 'f', Java treats decimal numbers as double and you get an error
    // float wrong = 3.14;  // COMPILE ERROR: incompatible types
    float correct = 3.14f;  // Works because of the f suffix
}

public static void main(String[] args) {
    double pi = 3.141592653589793;
    double accountBalance = 1_250_000.75;
    double interestRate = 0.045;   // 4.5%

    System.out.println("Pi: " + pi);                  // 3.141592653589793
    System.out.println("Balance: $" + accountBalance); // $1250000.75

    // Calculate interest
    double interest = accountBalance * interestRate;
    System.out.println("Interest: $" + interest);      // $56250.03375

    // Precision difference between float and double
    float  floatVal  = 1.123456789f;
    double doubleVal = 1.123456789;

    System.out.println("float:  " + floatVal);   // 1.1234568  (lost precision after 7 digits)
    System.out.println("double: " + doubleVal);   // 1.123456789 (accurate to 15 digits)
}

public static void main(String[] args) {
    boolean isLoggedIn = true;
    boolean isAdmin = false;
    boolean hasPermission = true;

    // Used in conditions
    if (isLoggedIn && hasPermission) {
        System.out.println("Access granted");   // This prints
    }

    if (isAdmin) {
        System.out.println("Welcome, admin");
    } else {
        System.out.println("Welcome, user");    // This prints
    }

    // Boolean from comparisons
    int age = 21;
    boolean canVote = age >= 18;
    boolean isTeenager = age >= 13 && age <= 19;

    System.out.println("Can vote: " + canVote);         // true
    System.out.println("Is teenager: " + isTeenager);    // false

    // Boolean with methods
    String email = "user@example.com";
    boolean validEmail = email.contains("@");
    System.out.println("Valid email: " + validEmail);    // true
}

public static void main(String[] args) {
    char letter = 'A';
    char digit = '7';
    char symbol = '$';
    char space = ' ';

    System.out.println("Letter: " + letter);   // A
    System.out.println("Digit: " + digit);      // 7
    System.out.println("Symbol: " + symbol);    // $

    // char is actually a number (Unicode code point)
    char letterA = 65;       // 65 is the Unicode value for 'A'
    System.out.println(letterA);   // A

    // Unicode escape sequences
    char copyright = '\u00A9';   // copyright symbol
    char omega = '\u03A9';       // Greek capital letter Omega
    System.out.println("Copyright: " + copyright);   // ©
    System.out.println("Omega: " + omega);            // Ω

    // You can do arithmetic with char (it is a numeric type)
    char ch = 'A';
    ch++;
    System.out.println(ch);   // B

    // Convert char to its numeric value
    char c = 'Z';
    int asciiValue = (int) c;
    System.out.println("ASCII value of 'Z': " + asciiValue);  // 90
}

public static void main(String[] args) {
    // String is a reference type, but you can create it like a primitive
    String name = "Folau";
    String greeting = "Hello, " + name + "!";

    System.out.println(greeting);             // Hello, Folau!
    System.out.println(name.length());        // 5
    System.out.println(name.toUpperCase());   // FOLAU

    // Strings are objects with methods - primitives do not have methods
    boolean startsWithF = name.startsWith("F");
    System.out.println(startsWithF);  // true
}

public static void main(String[] args) {
    // Array of integers
    int[] scores = {95, 87, 73, 100, 88};

    // Array of strings
    String[] names = {"Alice", "Bob", "Charlie"};

    System.out.println("First score: " + scores[0]);     // 95
    System.out.println("Second name: " + names[1]);      // Bob
    System.out.println("Array length: " + scores.length); // 5
}

class User {
    String name;
    int age;

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void greet() {
        System.out.println("Hi, I'm " + name + " and I'm " + age + " years old.");
    }
}

public static void main(String[] args) {
    // 'user' is a reference variable - it holds the memory address of a User object
    User user = new User("Folau", 30);
    user.greet();  // Hi, I'm Folau and I'm 30 years old.

    // Reference types can be null - primitives cannot
    User emptyUser = null;
    System.out.println(emptyUser);  // null
}

public static void main(String[] args) {
    // Widening: Java automatically converts to the larger type

    byte myByte = 42;
    short myShort = myByte;     // byte -> short (automatic)
    int myInt = myShort;        // short -> int (automatic)
    long myLong = myInt;        // int -> long (automatic)
    float myFloat = myLong;    // long -> float (automatic)
    double myDouble = myFloat; // float -> double (automatic)

    System.out.println("byte:   " + myByte);    // 42
    System.out.println("short:  " + myShort);   // 42
    System.out.println("int:    " + myInt);      // 42
    System.out.println("long:   " + myLong);     // 42
    System.out.println("float:  " + myFloat);    // 42.0
    System.out.println("double: " + myDouble);   // 42.0

    // This is also widening (int to double)
    int score = 85;
    double percentage = score;   // Automatically converts to 85.0
    System.out.println("Percentage: " + percentage);  // 85.0
}

public static void main(String[] args) {
    // Narrowing: you must explicitly cast with (type)

    double myDouble = 9.78;
    int myInt = (int) myDouble;  // Truncates the decimal, does NOT round
    System.out.println("double: " + myDouble);  // 9.78
    System.out.println("int:    " + myInt);      // 9 (decimal part lost!)

    // More examples
    int largeNumber = 130;
    byte smallByte = (byte) largeNumber;
    System.out.println("int: " + largeNumber);       // 130
    System.out.println("byte: " + smallByte);        // -126 (overflow! 130 exceeds byte range)

    double price = 49.99;
    float floatPrice = (float) price;     // double -> float
    long longPrice = (long) price;        // double -> long (truncates decimal)
    int intPrice = (int) price;           // double -> int (truncates decimal)

    System.out.println("double: " + price);         // 49.99
    System.out.println("float:  " + floatPrice);    // 49.99
    System.out.println("long:   " + longPrice);     // 49
    System.out.println("int:    " + intPrice);       // 49

    // Without the cast, you get a compile error
    // int x = 3.14;            // COMPILE ERROR
    int x = (int) 3.14;         // OK - x is 3
}

public static void main(String[] args) {
    // Wrapper classes provide useful utility methods

    // Parsing strings to numbers
    int num = Integer.parseInt("42");
    double price = Double.parseDouble("19.99");
    boolean flag = Boolean.parseBoolean("true");

    System.out.println(num);    // 42
    System.out.println(price);  // 19.99
    System.out.println(flag);   // true

    // Getting min and max values
    System.out.println("int max: " + Integer.MAX_VALUE);     // 2147483647
    System.out.println("int min: " + Integer.MIN_VALUE);     // -2147483648
    System.out.println("double max: " + Double.MAX_VALUE);   // 1.7976931348623157E308

    // Converting numbers to strings
    String numStr = Integer.toString(42);
    String hexStr = Integer.toHexString(255);   // "ff"
    String binStr = Integer.toBinaryString(10); // "1010"

    System.out.println("Hex: " + hexStr);    // ff
    System.out.println("Binary: " + binStr); // 1010

    // Comparing values
    int result = Integer.compare(10, 20);
    System.out.println("Compare 10 vs 20: " + result);  // -1 (10 < 20)
}

import java.util.ArrayList;
import java.util.List;

public static void main(String[] args) {
    // AUTOBOXING: primitive -> wrapper (automatic)
    Integer wrappedInt = 42;         // int 42 is autoboxed to Integer
    Double wrappedDouble = 3.14;     // double 3.14 is autoboxed to Double
    Boolean wrappedBool = true;      // boolean true is autoboxed to Boolean

    System.out.println(wrappedInt);     // 42
    System.out.println(wrappedDouble);  // 3.14
    System.out.println(wrappedBool);    // true

    // UNBOXING: wrapper -> primitive (automatic)
    int primitiveInt = wrappedInt;         // Integer is unboxed to int
    double primitiveDouble = wrappedDouble; // Double is unboxed to double

    System.out.println(primitiveInt);       // 42
    System.out.println(primitiveDouble);    // 3.14

    // Autoboxing is essential for Collections
    // ArrayList cannot hold primitive 'int', but autoboxing handles it
    List numbers = new ArrayList<>();
    numbers.add(10);    // autoboxing: int -> Integer
    numbers.add(20);    // autoboxing: int -> Integer
    numbers.add(30);    // autoboxing: int -> Integer

    // Unboxing when retrieving
    int first = numbers.get(0);   // unboxing: Integer -> int
    System.out.println("First: " + first);  // 10

    // Autoboxing in arithmetic expressions
    Integer a = 10;
    Integer b = 20;
    int sum = a + b;  // Both are unboxed, added, result stays as int
    System.out.println("Sum: " + sum);  // 30
}

public static void main(String[] args) {
    // Integer overflow - the value wraps around silently!
    int maxInt = Integer.MAX_VALUE;  // 2,147,483,647
    int overflow = maxInt + 1;

    System.out.println("Max int:     " + maxInt);     // 2147483647
    System.out.println("Max int + 1: " + overflow);   // -2147483648 (wrapped to minimum!)

    // This is a common bug when calculating large values
    int million = 1_000_000;
    int result = million * million;  // 1,000,000,000,000 - too big for int!
    System.out.println("Million squared (int):  " + result);   // -727379968 (wrong!)

    // Fix: use long
    long correctResult = (long) million * million;
    System.out.println("Million squared (long): " + correctResult);  // 1000000000000
}

import java.math.BigDecimal;

public static void main(String[] args) {
    // Floating-point precision problem
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    System.out.println("0.1 + 0.2 = " + sum);           // 0.30000000000000004 (not 0.3!)
    System.out.println("0.1 + 0.2 == 0.3? " + (sum == 0.3));  // false!

    // This is why you should NEVER use double for money
    double price = 0.10;
    double quantity = 3;
    double total = price * quantity;
    System.out.println("$0.10 x 3 = $" + total);  // $0.30000000000000004

    // Use BigDecimal for financial calculations
    BigDecimal bdPrice = new BigDecimal("0.10");
    BigDecimal bdQuantity = new BigDecimal("3");
    BigDecimal bdTotal = bdPrice.multiply(bdQuantity);
    System.out.println("BigDecimal: $0.10 x 3 = $" + bdTotal);  // $0.30
}

public static void main(String[] args) {
    // Cached range (-128 to 127): == works because Java reuses the same objects
    Integer x = 100;
    Integer y = 100;
    System.out.println(x == y);       // true (cached, same object)
    System.out.println(x.equals(y));  // true

    // Outside cached range: == fails because they are different objects
    Integer a = 200;
    Integer b = 200;
    System.out.println(a == b);       // false! (different objects in memory)
    System.out.println(a.equals(b));  // true  (correct way to compare)

    // ALWAYS use .equals() to compare wrapper objects
}

public static void main(String[] args) {
    Integer wrappedValue = null;

    // This throws NullPointerException at runtime!
    // int primitiveValue = wrappedValue;  // unboxing null -> crash

    // Safe approach: check for null first
    if (wrappedValue != null) {
        int safeValue = wrappedValue;
        System.out.println(safeValue);
    } else {
        System.out.println("Value is null, using default: 0");
        int safeValue = 0;
    }
}

public static void main(String[] args) {
    // WRONG: no suffix
    // long bigNumber = 3000000000;   // COMPILE ERROR: integer too large
    // float pi = 3.14;               // COMPILE ERROR: incompatible types

    // CORRECT: with suffix
    long bigNumber = 3000000000L;     // L suffix for long
    float pi = 3.14f;                 // f suffix for float

    System.out.println(bigNumber);    // 3000000000
    System.out.println(pi);           // 3.14

    // Tip: Use uppercase L to avoid confusion with the digit 1
    long value = 123456789L;  // Clear
    // long value = 123456789l;  // Confusing - lowercase l looks like 1
}

---