Utility Classes and Memory

🧰 Java’s Magical Toolbox: Utility Classes & Memory Magic

Imagine you have a giant toy box full of super helpful tools. You don’t have to build these tools yourself—Java gives them to you for FREE! Let’s explore this magical toolbox together.

🎯 The Big Picture

Think of Java like a superhero’s utility belt. Batman has gadgets ready to use. Java has utility classes—ready-made helpers that do cool stuff like:

• Calculate math problems instantly
• Generate random numbers (like rolling dice!)
• Create unique IDs (like fingerprints for data)
• Clean up memory (like a robot vacuum for your computer)

Let’s meet each tool in the belt!

🔢 Math Class Operations

What Is It?

The Math class is like having a genius calculator friend who knows ALL the math tricks!

Real Life Example

Imagine you’re building a video game. A character jumps. How high? The Math class calculates it!

// Find the bigger number
int score1 = 85;
int score2 = 92;
int winner = Math.max(score1, score2);
// winner = 92 🏆

// Find the smaller number
int loser = Math.min(score1, score2);
// loser = 85

// Round a number
double price = 19.7;
long rounded = Math.round(price);
// rounded = 20

// Power! (like 2 × 2 × 2)
double result = Math.pow(2, 3);
// result = 8.0

// Square root (what × what = 16?)
double root = Math.sqrt(16);
// root = 4.0

// Absolute value (always positive)
int distance = Math.abs(-50);
// distance = 50

🎮 Why It’s Cool

No need to write your own formulas! Java already knows:

• Math.PI = 3.14159… (circle magic!)
• Math.E = 2.71828… (science stuff!)

🎲 Random Number Generation

What Is It?

The Random class is like having magical dice that can have ANY number of sides!

Story Time

You’re making a game. The dragon can breathe fire that does 1-100 damage. How do you decide? RANDOM!

import java.util.Random;

Random dice = new Random();

// Roll a number between 0-99
int damage = dice.nextInt(100);

// Roll a number between 1-6 (like real dice!)
int diceRoll = dice.nextInt(6) + 1;

// Flip a coin (true or false)
boolean heads = dice.nextBoolean();

// Random decimal between 0.0 and 1.0
double chance = dice.nextDouble();

🎯 Quick Alternative

// Simple random between 0.0 and 1.0
double quick = Math.random();

// Random 1-10 using Math.random()
int num = (int)(Math.random() * 10) + 1;

💡 Pro Tip

Need the SAME random numbers every time (for testing)?

Random seeded = new Random(12345);
// Always gives same sequence!

⚙️ System Class

What Is It?

The System class is like the control room of your Java program. It talks to your computer!

What Can It Do?

// Print to screen (you use this ALL the time!)
System.out.println("Hello World!");

// Print errors (goes to error stream)
System.err.println("Oops! Something broke!");

// Get current time in milliseconds
// (since January 1, 1970)
long now = System.currentTimeMillis();

// More precise time (nanoseconds)
long precise = System.nanoTime();

// Stop the program RIGHT NOW
// (0 = success, other = error)
System.exit(0);

🔍 Environment & Properties

// Get environment variable
String home = System.getenv("HOME");

// Get system property
String javaVersion =
    System.getProperty("java.version");

// Copy array FAST
int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, 5);

💡 Fun Fact

System.currentTimeMillis() counts milliseconds since “Unix Epoch”—January 1, 1970. That’s Java’s “birthday clock”!

🛠️ Objects Utility Class

What Is It?

The Objects class is like a safety inspector for your objects. It prevents crashes!

The Problem It Solves

String name = null;
// This CRASHES! 💥
int length = name.length();
// NullPointerException!

The Solution

import java.util.Objects;

// Safe null check
String name = null;

// Returns true if null
boolean isNull = Objects.isNull(name);

// Returns true if NOT null
boolean exists = Objects.nonNull(name);

// Require non-null (throws error if null)
Objects.requireNonNull(name,
    "Name cannot be null!");

// Safe equals (no crash if null)
boolean same = Objects.equals(name, "Bob");
// Returns false, no crash!

// Safe hashcode
int hash = Objects.hashCode(name);
// Returns 0 if null, no crash!

// Safe toString
String text = Objects.toString(name, "Unknown");
// Returns "Unknown" if null

🎯 Why It Matters

NullPointerException is the #1 bug in Java programs! Objects class is your shield!

🆔 UUID and Base64

UUID - Unique IDs

Think of UUID like a snowflake—every single one is different!

import java.util.UUID;

// Create a unique ID
UUID id = UUID.randomUUID();
System.out.println(id);
// Something like:
// 550e8400-e29b-41d4-a716-446655440000

// Convert string to UUID
UUID parsed = UUID.fromString(
    "550e8400-e29b-41d4-a716-446655440000"
);

When To Use UUID?

• User accounts
• Order numbers
• Session tokens
• File names that can’t clash

Base64 - Secret Encoding

Base64 turns data into safe text. Like writing a secret code!

import java.util.Base64;

String secret = "Hello World!";
byte[] bytes = secret.getBytes();

// ENCODE (hide it)
String encoded = Base64.getEncoder()
    .encodeToString(bytes);
// "SGVsbG8gV29ybGQh"

// DECODE (reveal it)
byte[] decoded = Base64.getDecoder()
    .decode(encoded);
String revealed = new String(decoded);
// "Hello World!"

💡 Base64 Is NOT Encryption!

It’s encoding—anyone can decode it. It’s for safe transport, not secrets!

🗑️ Garbage Collection

What Is It?

Imagine your room fills with toys you’re not playing with anymore. Garbage Collection (GC) is like a magical cleaning robot that finds unused toys and puts them away!

graph TD
    A["You Create Object"] --> B["Object Lives in Memory"]
    B --> C{Still Using It?}
    C -->|Yes| B
    C -->|No| D["Object Becomes Garbage"]
    D --> E["GC Robot Cleans It Up"]
    E --> F["Memory is Free Again!"]

How It Works

// Create object (uses memory)
String greeting = new String("Hello!");

// Object no longer needed
greeting = null;  // Now it's "garbage"

// GC will clean it up automatically!

Can You Force GC?

// SUGGEST garbage collection
// (Java might ignore you!)
System.gc();

// This is just a HINT, not a command!

💡 Important Truth

• You cannot force GC to run
• Java decides WHEN to clean
• Trust Java—it’s very smart about this!

💾 Memory Management

The Two Memory Zones

graph LR
    A["Java Memory"] --> B["Stack"]
    A --> C["Heap"]
    B --> D["Small & Fast"]
    B --> E["Method calls"]
    B --> F["Primitive variables"]
    C --> G["Big & Flexible"]
    C --> H["Objects live here"]
    C --> I["GC cleans here"]

Stack Memory

• Fast like a sticky note
• Stores: method calls, local variables, references
• Automatically cleaned when method ends

Heap Memory

• Big like a warehouse
• Stores: all objects you create with new
• GC cleans when objects aren’t needed

Example

public void example() {
    // 'number' is on the STACK
    int number = 42;

    // Reference 'name' is on STACK
    // Actual String object is on HEAP
    String name = new String("Java");

}  // Method ends → Stack cleaned
   // Heap object waits for GC

Memory Problems to Avoid

Memory Leak = Keeping references to objects you don’t need

// BAD: List grows forever!
List<Object> list = new ArrayList<>();
while(true) {
    list.add(new Object());
}
// OutOfMemoryError! 💥

🔄 Object Lifecycle

The Life of an Object

Every Java object has a life story, like a butterfly!

graph TD
    A["1. CREATED"] --> B["Constructor runs"]
    B --> C["2. IN USE"]
    C --> D["Your code uses it"]
    D --> E{Still referenced?}
    E -->|Yes| C
    E -->|No| F["3. UNREACHABLE"]
    F --> G["Eligible for GC"]
    G --> H["4. COLLECTED"]
    H --> I["Memory freed!"]

Stage 1: Creation

// Object is BORN!
Dog buddy = new Dog("Buddy");
// Constructor runs, object is ready

Stage 2: In Use

// Object is ALIVE and working
buddy.bark();
buddy.fetch();

Stage 3: Unreachable

// Object becomes ORPHAN
buddy = null;
// OR
buddy = new Dog("Max");
// Old "Buddy" is now unreachable

Stage 4: Collection

// GC finds and removes it
// Memory is FREE again!
// This happens automatically

The finalize() Method (Deprecated!)

// OLD WAY - Don't use this anymore!
@Override
protected void finalize() {
    // Cleanup code here
}
// This is DEPRECATED since Java 9

Modern Cleanup

// Use try-with-resources instead!
try (FileReader reader =
        new FileReader("file.txt")) {
    // Use reader
}  // Automatically closed!

🎯 Quick Summary

🚀 You’re Now a Memory Master!

You learned:

• ✅ Math tricks without writing formulas
• ✅ Random numbers for games and apps
• ✅ System controls for your program
• ✅ Null-safe object handling
• ✅ Unique IDs that never clash
• ✅ How Java cleans up memory automatically
• ✅ The full life cycle of objects

Remember: Java takes care of memory FOR you. Your job is to:

1. Create objects when needed
2. Set references to null when done
3. Let Java’s GC do the rest!

You’ve unlocked the secrets of Java’s utility belt! 🦸‍♂️