OutOfMemoryError in Java is an important Core Java topic because it appears in real projects, debugging sessions, and interviews. Learn the meaning first, then connect it to a small working example so the rule does not stay abstract.
For this page, focus on what problem OutOfMemoryError in Java solves, where developers usually make mistakes, and how to verify the result. The audit note for this lesson was: under 650 content words .
A strong understanding of OutOfMemoryError in Java should include syntax, behavior, one realistic use case, one failure case, and one quick way to check your work with tools or output.
OutOfMemoryError in Java should be studied as a practical Java programming lesson, not as a label. Start by naming the input, the rule that changes the input, and the result a learner should be able to predict after reading the page.
In the core-java > errors > out-of-memory-error page, the notes should connect the definition with a working scenario, a mistake that beginners actually make, and the exact check that proves the fix. That makes the topic useful for coding, debugging, and interview revision.
The OutOfMemoryError (OOM) is thrown when the JVM cannot allocate an object because it has run out of heap memory and the garbage collector cannot free enough space. This is a serious error that usually indicates a memory leak or insufficient heap configuration.
# Increase heap size (temporary fix)
java -Xmx512m -Xms256m MyApplication
# For large applications
java -Xmx2g MyApplication
# Enable GC logging to diagnose
java -Xmx512m -verbose:gc -XX:+PrintGCDetails MyApplication// ⌠Loading millions of records into memory
List<Record> allRecords = database.findAll(); // OOM for large tables!
allRecords.forEach(r -> process(r));// ✅ Process in batches
int pageSize = 1000;
int page = 0;
List<Record> batch;
do {
batch = database.findAll(PageRequest.of(page++, pageSize));
batch.forEach(r -> process(r));
batch.clear(); // Help GC
} while (batch.size() == pageSize);
// ✅ Or use streaming (Spring Data)
database.streamAll().forEach(r -> process(r));class Cache {
// ⌠Static map grows forever "†never cleared!
static Map<String, Object> cache = new HashMap<>();
static void add(String key, Object value) {
cache.put(key, value); // Memory leak!
}
}// ✅ Use WeakHashMap "†entries removed when key is GC'd
static Map<String, Object> cache = new WeakHashMap<>();
// ✅ Or use a bounded cache with eviction
static Map<String, Object> cache = Collections.synchronizedMap(
new LinkedHashMap<>(100, 0.75f, true) {
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > 100; // Max 100 entries
}
}
);
// ✅ Or use Caffeine/Guava cache with TTL
Cache<String, Object> cache = Caffeine.newBuilder()
.maximumSize(1000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();// ⌠Reading entire 10GB file into memory
byte[] content = Files.readAllBytes(Paths.get("huge-file.csv")); // OOM!// ✅ Stream lines one at a time
try (Stream<String> lines = Files.lines(Paths.get("huge-file.csv"))) {
lines.forEach(line -> processLine(line));
}
// ✅ Or use BufferedReader
try (BufferedReader reader = new BufferedReader(new FileReader("huge-file.csv"))) {
String line;
while ((line = reader.readLine()) != null) {
processLine(line);
}
}When studying OutOfMemoryError in Java, separate three things: the concept, the syntax, and the situation where it is useful. This prevents the lesson from becoming a list of commands with no practical meaning.
In Core Java, OutOfMemoryError in Java becomes easier when you build a tiny example first, then increase complexity. Add one realistic input, one invalid or boundary input, and one explanation of why the result changes.
class OutOfMemoryErrorinJavaReview {
public static void main(String[] args) {
String state = "ready";
System.out.println("OutOfMemoryError in Java: " + state);
}
}String value = null;
if (value == null) {
System.out.println("OutOfMemoryError in Java: handle the missing value before continuing");
}Memorizing OutOfMemoryError in Java without the situation where it is useful.
Connect OutOfMemoryError in Java to a concrete Java programming task.
Testing OutOfMemoryError in Java only with the perfect input.
Include empty, missing, duplicate, incompatible, or failed cases when relevant.
Changing code before reading the visible symptom or error message.
Inspect the output, state, configuration, or stack trace connected to OutOfMemoryError in Java.
Memorizing OutOfMemoryError in Java without the situation where it is useful.
Connect OutOfMemoryError in Java to a concrete Java programming task.
"Java heap space" means the heap is full. "GC overhead limit exceeded" means GC is running constantly (>98% of time) but recovering less than 2% of heap "" effectively the heap is full but GC keeps trying.
Use JVM flags: -Xms for initial heap, -Xmx for maximum heap. Example: java -Xms256m -Xmx2g MyApp. For servers, set both to the same value to avoid heap resizing overhead.
Use profiling tools like VisualVM (free), JProfiler, or YourKit. Take heap dumps with jmap and analyze with Eclipse MAT. Look for objects that keep growing in count over time.
A memory leak in Java occurs when objects are no longer needed but are still referenced, preventing GC from collecting them. Common causes: static collections, unclosed streams, event listeners not removed, and ThreadLocal variables.
Metaspace stores class metadata. "OutOfMemoryError: Metaspace" occurs when too many classes are loaded (common with dynamic class generation or many classloaders). Increase with -XX:MaxMetaspaceSize=256m.
Explore 500+ free tutorials across 20+ languages and frameworks.