Java JVM Memory Model (Heap, Stack, GC) Quiz

0 Passed

0% acceptance

Understand the JVM memory architecture including heap and stack management, garbage collection mechanisms, classloader hierarchy, memory leak prevention, and JVM optimization techniques.

40 Questions

~80 minutes

Question 1

What is the primary difference between stack and heap memory in JVM?

Stack is for primitive variables and method calls, heap is for objects

Stack is faster, heap is slower

Stack is managed manually, heap is automatic

Stack is larger, heap is smaller

Question 2

Which memory area is used for storing method parameters and local variables?

Heap memory

Stack memory

Method area

Program counter

Question 3

What happens when the stack memory is full?

StackOverflowError is thrown

OutOfMemoryError is thrown

Program terminates gracefully

Memory is automatically increased

Question 4

Which of these is stored in heap memory?

java

String str = new String("Hello");
int[] array = new int[10];

The String object and int array

Only the references str and array

The literal "Hello" and array elements

Nothing, primitives are stored in stack

Question 5

What is garbage collection in JVM?

Automatic memory management that reclaims unused heap memory

Manual memory deallocation by programmer

Stack memory cleanup

Disk space optimization

Question 6

Which garbage collection algorithm marks objects and then sweeps unreachable ones?

Mark-and-sweep

Copying collector

Reference counting

Generational GC

Question 7

What is the purpose of generational garbage collection?

To take advantage of the fact that most objects die young

To collect garbage from different memory regions

To parallelize garbage collection

To compress memory

Question 8

Which JVM memory area stores class-level information?

Heap

Stack

Method area (Metaspace)

Program counter register

Question 9

What causes a memory leak in Java?

Objects that are no longer needed but still have references

Using too many primitive variables

Creating large arrays

Using static methods

Question 10

How can static collections cause memory leaks?

java

public class Cache {
    private static Map<String, Object> cache = new HashMap<>();
    
    public static void add(String key, Object value) {
        cache.put(key, value);
    }
}

Static references prevent garbage collection of the collection and its contents

Static methods consume more memory

Collections can't be static

Only primitive static variables cause leaks

Question 11

What is the classloader hierarchy in JVM?

Bootstrap -> Extension -> Application (System) ClassLoader

Application -> Extension -> Bootstrap ClassLoader

System -> Bootstrap -> Extension ClassLoader

Extension -> Application -> Bootstrap ClassLoader

Question 12

What is the delegation model in classloading?

A classloader delegates to its parent before trying to load a class itself

Parent classloaders delegate to child classloaders

All classloaders work independently

Only bootstrap classloader uses delegation

Question 13

Which classloader loads the JDK internal classes?

Bootstrap ClassLoader

Extension ClassLoader

Application ClassLoader

Custom ClassLoader

Question 14

What is Metaspace in JVM?

Replacement for PermGen that stores class metadata

Area for temporary object storage

Stack memory area

Garbage collection algorithm

Question 15

How does JVM handle memory allocation for objects?

Objects are allocated in Eden space of young generation

Objects are allocated directly in old generation

Objects are allocated in stack memory

JVM uses malloc() for allocation

Question 16

What is a minor GC vs major GC?

Minor GC collects young generation, major GC collects old generation

Minor GC is faster, major GC is slower

Minor GC runs more frequently, major GC less frequently

All of the above

Question 17

Which JVM flag sets the maximum heap size?

java

-Xmx2g

-Xmx (maximum heap size)

-Xms (minimum heap size)

-Xmn (young generation size)

-Xss (stack size)

Question 18

What is JVM heap fragmentation?

Free memory scattered in small chunks, making allocation difficult

Heap memory becoming full

Stack memory overflow

Memory leaks accumulation

Question 19

How can you monitor JVM memory usage?

Using jstat, jmap, VisualVM, or JMX

Using System.gc() calls

Using Runtime.getRuntime().totalMemory()

Only through heap dumps

Question 20

What is the purpose of the -XX:+UseG1GC flag?

java

java -XX:+UseG1GC -Xmx4g MyApp

Enables the G1 garbage collector

Enables parallel GC

Enables CMS GC

Enables serial GC

Question 21

What causes ClassNotFoundException?

Class not found in classpath during runtime

Class file corrupted

Class has compilation errors

Class is abstract

Question 22

How does JVM optimize memory usage?

Through escape analysis, string interning, and object pooling

By using more heap memory

By reducing stack size

By disabling garbage collection

Question 23

What is the difference between PermGen and Metaspace?

Metaspace is dynamic and uses native memory, PermGen was fixed-size heap area

PermGen is in Java 8+, Metaspace is older

Metaspace stores objects, PermGen stores classes

They are identical

Question 24

How can listeners cause memory leaks?

java

public class EventSource {
    private List<EventListener> listeners = new ArrayList<>();
    
    public void addListener(EventListener listener) {
        listeners.add(listener);
    }
}

EventSource holds references to listeners, preventing their garbage collection

Listeners consume too much memory

Event handling is slow

Listeners can't be garbage collected

Question 25

What is the JVM's native method stack?

Stack for native method execution (JNI)

Stack for Java method calls

Heap area for native objects

Memory for native libraries

Question 26

How does the JVM handle finalization?

finalize() method is called before garbage collection

finalize() guarantees immediate cleanup

finalize() runs in a separate thread

finalize() is deprecated and should not be used

Question 27

What is JVM heap tuning?

Adjusting heap size, generation sizes, and GC parameters for optimal performance

Increasing heap size indefinitely

Disabling garbage collection

Using only young generation

Question 28

Which causes OutOfMemoryError: Java heap space?

Heap is full and GC cannot free enough memory

Stack is full

Metaspace is full

Native memory is exhausted

Question 29

How can you force garbage collection?

java

System.gc(); // Not recommended

Using System.gc() (but it's only a hint)

Using Runtime.gc()

GC cannot be forced

Using -XX:+DisableExplicitGC

Question 30

What is the purpose of the -XX:MaxMetaspaceSize flag?

java

java -XX:MaxMetaspaceSize=256m MyApp

Limits the maximum size of Metaspace

Sets maximum heap size

Limits stack size

Sets young generation size

Question 31

What is object reachability in garbage collection?

An object is reachable if there's a path from GC roots to it

An object is reachable if it's in young generation

An object is reachable if it's not null

An object is reachable if it's in heap

Question 32

How does the JVM handle circular references?

Garbage collector can detect and collect circular references

Circular references prevent garbage collection

JVM breaks circular references automatically

Circular references cause memory leaks

Question 33

What is the JVM's program counter register?

Contains address of currently executing JVM instruction

Counts program execution time

Stores program variables

Manages program threads

Question 34

How can you detect memory leaks in Java applications?

Using heap dumps, profilers, and monitoring tools

Using System.out.println() statements

Using debugger breakpoints

Memory leaks cannot be detected

Question 35

What is the difference between soft, weak, and phantom references?

Soft: cleared before OOM, weak: cleared anytime, phantom: enqueued before reclamation

Soft: memory-sensitive, weak: for caches, phantom: for cleanup

All of the above

They are identical

Question 36

How does JVM optimize string memory usage?

java

String s1 = "hello"; // String pool
String s2 = new String("hello"); // Heap

Through string interning and pool

By compressing strings automatically

By storing all strings in heap

By limiting string length

Question 37

What is JVM bytecode verification?

Process that checks bytecode for validity and security

Compilation of Java to bytecode

Optimization of bytecode

Execution of bytecode

Question 38

How can you reduce GC pauses?

Use larger heap, tune GC parameters, reduce object allocation

Use smaller heap

Disable GC

Use only serial GC

Question 39

What is the JVM's just-in-time (JIT) compilation?

Converts frequently executed bytecode to native code at runtime

Compiles Java source to bytecode

Interprets bytecode line by line

Optimizes bytecode before execution

Question 40

Understanding JVM Memory Model means you now write code that:

Properly manages heap and stack memory, understands garbage collection behavior, prevents memory leaks, configures JVM parameters appropriately, and optimizes memory usage for better performance

Uses as much memory as possible

Ignores memory management entirely

Only uses stack memory

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Rust

30 quizzes

Cargo and Project Setup

Variables and Mutability

Data Types

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Java

Java Basics & JVM Fundamentals

50 in-depth questions (30 with code) covering Java platform independence, JVM architecture, compilation, bytecode, class loading, memory areas, garbage collection, and your first real Java program.

Variables, Data Types & Type Casting

40 focused questions Java primitive and reference types, variable declaration rules, widening/narrowing conversions, the final keyword, and the most common type-casting pitfalls.

Operators & Expressions

40 medium-to-advanced questions Java operators & expressions that force deep thinking about arithmetic, relational, logical, assignment, and ternary operators — including precedence traps, short-circuit behavior, compound assignment quirks, and real-world expression bugs.

Strings & String Methods

35 in-depth questions covering String immutability, object creation, comparison behavior, common methods, StringBuilder/StringBuffer usage, and performance implications in real-world Java code.

Numbers & Math Class

35 deep-dive questions on Java's numerical capabilities, from Math utilities and rounding behavior to BigInteger/BigDecimal precision, number formatting, and the subtle dangers of primitive overflow.

Arrays & Multi-Dimensional Arrays

35 deep and practical questions on Java arrays — from declaration and initialization to advanced 2D/3D usage, Arrays utility methods, common pitfalls, and performance gotchas that trip even senior developers.

Classes, Objects & Constructors

40 deep and challenging questions that explore every corner of object creation, constructor behavior, the true meaning of this, the subtle differences between instance and static members, and the complete lifecycle of objects in Java.

Methods, Parameters & Overloading

35 challenging and insight-revealing questions that dive deep into how Java really handles method invocation, parameter passing, overloading resolution, varargs behavior, return type rules, and the subtle edge cases that surprise even experienced developers.

Packages & Import Statements

40 deep, practical, and often overlooked questions about Java packages — from directory structure enforcement and classpath mechanics to import rules, static imports, naming conventions, and the subtle ways packages affect accessibility, compilation, and runtime behavior.

Control Flow (if, else, switch)

35 deep, real-world, and frequently misunderstood questions about Java control flow — covering if-else pitfalls, dangling else, fall-through dangers, modern switch expressions, pattern matching, exhaustive checking, and the best practices that prevent bugs in production code.

Loops (for, while, do-while)

35 deep, practical, and often misunderstood questions about Java loops — from subtle break/continue label behavior and enhanced for-loop limitations to infinite loop detection, do-while quirks, loop unrolling myths, and the performance & safety best practices used in real production systems.

Encapsulation & Abstraction in OOP

35 in-depth questions (15 with code) covering encapsulation principles, getters/setters implementation, abstraction concepts, abstracting behavior, and design benefits in object-oriented programming.

Polymorphism (Compile-Time & Runtime)

35 in-depth questions (15 with code) covering method overloading as compile-time polymorphism, overriding as runtime polymorphism, dynamic method dispatch, upcasting/downcasting, and why polymorphism matters in object-oriented design.

Interfaces, Abstract Classes & Multiple Inheritance

35 in-depth questions (15 with code) covering interface basics, abstract class fundamentals, default/static methods in interfaces, functional interfaces, and multiple inheritance resolution in Java.

Exception Handling (try, catch, finally)

40 in-depth questions (20 with code) covering types of exceptions, try/catch syntax, finally block purpose, stack traces, and best practices in Java exception handling.

Custom Exceptions & Exception Hierarchy

30 in-depth questions (15 with code) covering creating custom exceptions, throw vs throws, checked vs unchecked exceptions, chained exceptions, and designing exception structures in Java.

Collections Framework (List, Set, Map)

35 in-depth questions (18 with code) covering List types (ArrayList, LinkedList), Set types (HashSet, TreeSet), Map types (HashMap, TreeMap), Collections utility class, and choosing the right collection for different use cases in Java.

Generics Deep Dive

35 in-depth questions (18 with code) covering why generics exist, generic methods, bounded type parameters, wildcards (? extends, ? super), and raw types pitfalls in Java.

Java I/O (Files, Streams, Readers/Writers)

35 in-depth questions (18 with code) covering Input/Output streams, Readers vs Writers, File operations, Buffered I/O, and handling I/O exceptions in Java.

Date & Time API (java.time)

35 in-depth questions (18 with code) covering LocalDate & LocalTime, LocalDateTime & ZonedDateTime, formatting dates, parsing dates, and Duration & Period in Java's modern date-time API.

Streams API (map, filter, reduce)

Master the Java Streams API for functional-style operations on collections. Learn to create streams, use intermediate operations like map and filter, apply terminal operations, perform reductions, and follow best practices for efficient stream processing.

JVM Memory Model (Heap, Stack, GC)

Understand the JVM memory architecture including heap and stack management, garbage collection mechanisms, classloader hierarchy, memory leak prevention, and JVM optimization techniques.