Java learning path: the right order of 12 topics

Java topics build on each other like floors of a building. Arrays are hard to work with without loops. Sorting needs arrays, loops and conditions all at once. If you skip a floor, you often only notice weeks later, when a task combines two topics.

An example: bubble sort consists of two nested loops, a comparison and a swap in an array. If you're still unsure about loops, you're fighting three things at once and decide that sorting is hard. But the real problem is two floors further down.

That's why one simple rule pays off: a topic is only done when you can solve a task on it without a template. Reading and understanding aren't enough.

You need these five topics in every program. This is where most of your time is well spent.

1. Input and output, variables, data types. Printing text, calculating with int, double and String, reading input with a Scanner. All of it is in the article input and output in Java.
2. Conditions. if, else, comparisons, && and ||. See conditions in Java.
3. Loops. for, while, do-while, break. Most thinking errors happen here, so take your time. See loops in Java.
4. Arrays. Many values in one variable, going through them with loops, finding the minimum and the sum.
5. Strings. Counting characters, cutting out parts, comparing strings correctly.

You're ready to move on when you can write this program without help: store five numbers in an array, print the largest and count how many are even. It combines everything from stage 1:

1int[] numbers = {7, 12, 3, 18, 5};2int max = numbers[0];3int even = 0;4for (int n : numbers) {5    if (n > max) {6        max = n;7    }8    if (n % 2 == 0) {9        even++;10    }11}12System.out.println("Max: " + max + ", even: " + even);

Max: 18, even: 2

Now you learn to split code into sensible parts.

1. Methods and recursion. Parameters, return values, one method for one job. Recursion belongs here because it's just a method that calls itself. See methods and recursion.
2. Classes and objects. Your own types with fields, constructors and methods. This is also where the difference between static and objects comes up. See classes and objects.
3. Lists and maps. ArrayList and HashMap, for when an array is too rigid.

You're ready to move on when you can write a class BankAccount with a balance, deposit and withdraw, and manage several accounts in a list.

1. Inheritance and interfaces. Pulling out shared behaviour, using several classes through one common type.
2. Exceptions and enums. Handling errors with try and catch, fixed sets of values as an enum. See exceptions and enums.
3. Lambdas and streams. Short functions as values, filtering and transforming data. Important: only once loops are second nature.
4. Generics and modern Java. Your own classes for any type, record and newer language features.

How much of this stage you need depends on your course. At school it varies by syllabus. AP Computer Science A, for example, was revised for the 2025–26 school year, and according to the College Board the revised course no longer has a unit on inheritance. At university, this stage usually belongs to the first or second programming course (CS1 or CS2). Check your syllabus or course description to see what's expected of you.

Once the twelve topics are solid, the next block follows: searching, sorting, recursion and backtracking, lists, stacks and queues, trees, heaps, hashing and graphs. That's the material of a data structures course (often called CS2) at university, and it also comes up in technical job interviews. A good way in is the article on simple sorting algorithms. Only start once you're confident with arrays, methods and classes. Almost every algorithm uses all three.

• Streams instead of loops. A one-liner from a video looks elegant. But exams often ask for a loop, and you'll understand streams poorly without loops anyway.
• Only reading, never writing. If you read ten articles and solve no tasks, you end up feeling you know everything and can't do any of it.
• Skipping error messages. Every message you've understood once saves you time later.
• Big projects too early. Your own game is great, but only after stage 2. Before that, it usually ends in frustration.

A note on fairness: there is no single correct order. Many courses deliberately start with objects, for example with BlueJ, and cover loops later. AP Computer Science A also begins with a unit on using objects and methods. An A-level or a university CS1 course may order the topics differently again, and the programming language depends on the course or exam board. That works too. In that case, practise the topics from stage 1 alongside, so you don't get stuck on simple loops when you reach methods and classes.

The Java Basics course in Jario follows exactly these twelve topics, one chapter per topic, from your first output to streams and generics. Each chapter has a short article with examples you can run and a “Common mistakes” section. Then come tasks from “Easy” through “Medium” to “Hard”, which tests check instantly. You see “x of y solved” and next time you continue where you left off. The first two chapters are free with a free account, no payment details needed, and everything runs in the browser without installing anything. If you keep going after that, the Java Algorithms course covers the topics from the section above.

If you only have a little time each day, learn Java in 30 minutes a day shows you how to split this order into small sessions. For university students there's the plan for passing your first programming course, and for high school students the AP Computer Science A study plan.

Start with topic 1, even if it looks easy. If you get the basics solid in a few days, you'll move much faster later on.