From Java Padawan to Java Jedi

What does a potential Java junior need to know to get the first job or even qualify for a trainee position in a good company? What tools will help a Java programmer reach the next level? Which technologies should you study, and which ones are better to hold off on?

There is no standard answer to these questions, just as there is no single action plan that would suit absolutely everyone. Some companies are striving for development, constantly introducing new technologies and testing the capabilities of new versions of the language, while others stubbornly cling to old ones. There are also middle options, and perhaps these are most of them.

I get asked this question so often that I decided to write an article that I can then refer to in order to answer it. In addition, it will be useful not only to those who ask me personally but also to everyone who has already decided (or did not decide in any way) to connect their lives with Java programming.

What Sources Did I Use to Answer the Main Question of the Article?

To answer the main question of the article as completely as possible, I relied on:

• My own experience as a senior Java developer who interviewed a lot of potential Java juniors
• My experience as a tutor (or rather, the experience of my students)
• The results of one survey conducted by CodeGym Portal for its alumni
• Some answers from internet forums

First of All: Core Java Is a Must

Core Java usually means the basic foundations of the programming language. It contains the following components.

Java syntax

• Classes, variables, and methods
• Primitive data types
• Strings
• Basic operators
• Basic constructions: loops, branches

Java syntax is a kind of ABC of this language. Students learn it by doing, like little children learn to read and to write. The most difficult concepts here are the principles of programming, such as loops and branches. They could be tough for absolute beginners, but usually after coding some tasks, future programmers start to get a feel for them.

Before they get their first job offer as a Java developer or Java trainee, 92.4% of programmers know Java syntax on a good or excellent level. What about the other 7.6%? They knew it on an intermediate level and were lucky enough to get a trainee offer. However, it’s pure luck. Every applicant must be fluent in Java syntax, and thank goodness it’s fast and easy to master.

Object-oriented programming (OOP)

Java and OOP are almost synonyms because everything in this programming language is an object.

If you’re used to procedural programming, it can be tricky at first to rearrange and think in object style. However, in fact, OOP is not so difficult. Moreover, it is a very beautiful concept. It’s important to write a lot of code and at the same time think about how object hierarchies are built.

The main subtopics of OOP are class inheritance, interface implementation, abstraction of data and behavior, encapsulation of data and class implementation, polymorphism, and virtual methods.

Most (80.3%) of the people who get their first Java-related job have known OOP principles well and used them all the time.

However “good knowledge” sometimes can have different definitions depending on your experience. “I read about OOP and used inheritance and encapsulation. I thought I knew it well, but I realized that I seemed to know something before, but did not understand the nuances. A real deep understanding of the levels of abstraction and how to use them came to me only during the work as a Java trainee on a big project,” said Andy, who now works as Java junior for one of the international outsource companies.

According to the CodeGym Portal survey, 78.8% of Java juniors and trainees use OOP in their job very often, 12.1% from time to time, and 7.6% of trainees use them rarely (usually they work with unit testing and different small tasks).

Collections framework

A group of individual objects represented as a single unit is a collection. Java provides a collections framework for different collections. Collections are based on popular data structures: lists, regular and connected, sets, hash maps, and so on. So while studying collections, it would be nice to get a little more familiar with data structures as well.
Main subtopics:

• List
• Set
• Map
• ArrayList
• LinkedList
• Queue
• Deque
• HashSet, HashMap, HashTable
• TreeSet, TreeMap The main difficulty in learning about collections is figuring out how they work and when to use which structure. It comes with practice. In addition, of the entire multitude of structures in real work, only a few are constantly used. As a tutorial, it can be useful to recreate your own version of the collection. Almost all (96.9%) Java juniors and trainees use the collection framework on their first job, and 80.3% of respondents have known collections at a good or excellent level before getting their first job offer.

Exception handling

An exception is an abnormal situation that can arise when your program is executed. All exception classes are subtypes of the java.lang.Exception class. The exception handling mechanism significantly simplifies bug catching processes in programs. Usually, students start to use exceptions pretty early, and this topic definitely deserves your attention.
Main subtopics:

• Exceptions handling mechanism
• Try-catch-finally
• Throw, throws
• Hierarchy of exceptions in Java
• Checked/unchecked exceptions
• Difference between error and exception
• Unreachable catch block error
• Manual exceptions throwing

Exceptions are used by every Java trainee and Java junior in their jobs, and interviewers ask questions about this mechanism very often.

Java input/output streams

Java performs input and output operations using streams. A stream is a kind of continuous flow of data. In Java programs, you need to read or write data pretty often. It is not the easiest topic for beginners, and sometimes it is not used often in newbies’ work (it really depends on the project they work at). Well, 22.7% of people who got their first Java junior/trainee job said that they use I/O streams often, 31.8% from time to time, 25.8% rarely. So a little less than 20% haven’t used them at all during their first year in a Java developer’s role.

Main subtopics:

• Byte streams (FileInputStream, FileOutputStream)
• Character streams (FileReader, FileWriter)
• Standard streams (System.in, System.out)

Java multithreading/concurrency

Here we’ve got the most advanced core Java topic of all. Almost all students have difficulties with understanding and using multithreading, but later, when they reach zen in the art of juggling with different threads, programmers begin to understand how well this technology is implemented in Java and how effective it can be.

Nevertheless, if it is very difficult for you, multithreading is the topic you don’t need to delve into at first. Thus, only 12.1% of respondents noted that they knew the topic at a good level before their first offer, while 31.8% admit that they did not understand anything about this topic at all. The majority (56.2%) of those surveyed said they “had some idea” about multithreading when they started. Hence, multithreading can be your competitive advantage in Java junior interviews. It is up to you to dive deep into it or get initial ideas. Solve some coding problems and focus on other topics.

Main subtopics:

• Lifecycle of a thread (new, runnable, waiting, timed waiting, terminated)
• Daemons
• Thread synchronization
• Handling thread deadlock
• Thread operations
• Wait, notify, notifyAll
• Interrupting threads
• Sleep, yield, join

During the first year working as a Java trainee or Junior developer, 9.1% have used multithreading often and 36.4% from time to time, while 39.4% used it rarely.

Lambda expressions

Java lambda expressions appeared in Java 8, but beginners often ignore this convenient tool. Lambdas extended Java, making the functional programming concept available in this language. A lambda expression is a function that can be created without belonging to any class, and you can pass it as an object or execute it on demand. Only 22.7% of respondents have known lambdas well before their first job offer, while 48.5% estimated their knowledge of the topic as “close to zero.” At the same time, over 85% of new programmers said that they used lambda expressions in their first working year.

Main subtopics:

• Lambdas, single method interface
• Anonymous interface implementations
• Lambda type inference
• Lambda parameters
• Lambda function body
• Returning a value from a lambda expression
• Lambdas as objects
• Variable capture
• Method references as lambdas

Thus, we can say that knowledge of core Java for any potential Java junior and even trainee is a must. Of course, you can get an offer if you know all the topics perfectly, and multithreading and lambda expressions somewhat less. However, these topics can become your competitive advantage when looking for a job. All the same, you will most likely need to work with both.

In my practice, I met guys who got work knowing only the basic concepts — Java Syntax and OOP. Most often they became Java trainees, but sometimes I came across someone with almost zero Java junior skills. On one hand, they were lucky: They realized their dream of becoming a programmer and could learn directly from work tasks. On the other hand, employers quickly realized that their skill level was weak, and for a long time they received the same type of monotonous tasks, which was often frustrating. My advice to such programmers is to grow faster until you are tired of all this. Solve practical problems, read — and move on to the next stage.

Where to learn core Java topics

CodeGym is one of my favorite online courses that is dedicated to core Java. You can find here all the core Java topics (except lambdas for the moment) and more than 1,200 exercises.
Lambda expressions on jenkov.com has a nice tutorial where you can find everything you need to know about lambdas.
Java on CodeCademy. CodeCademy is one of the most famous platforms for practical learning. In this course, you can find most of the core Java topics.

Algorithms and Data Structures: Questionable

One of the most controversial questions in learning any programming language is whether students should learn standard sorting and searching algorithms. One side insists that all efficient algorithms have long been written and included in libraries. Hence, anyone can just use them.

Their opponents are sure that writing algorithms on their own is an excellent exercise in programmer thinking, and besides, it is a test for its presence in a student. I am more likely to belong to the latter, especially given the fact that at Java junior interviews they are often asked to write one or another algorithm, sometimes even on a piece of paper. Although knowledge of algorithms is not related to knowledge of Java as such, I recommend all future programmers work on this topic. It will not be superfluous.

Another thing is that during the real work of a programmer, you most likely won’t need the bubble sort algorithm and the like. It will be much more important to know in which libraries the standard algorithms can be found. In the survey, 69.6% of students claimed that they knew and coded sorting and search algorithms at a good and average level before receiving the first job offer.

We have already addressed the topic of data structures when we talked about Java collections. Again, I consider it necessary to understand their architecture in order to know where and what to use, and why. Therefore, I often ask my students to write their own class for this or that data structure.

Again, while working, everyone usually uses standard data structures, and not all of them.

Where to learn algorithms and data structures

First, you may find a good book, such as Algorithms by Robert Sedgewick and Kevin Wayne. Also, the same authors have an online course on Coursera. This one is one of my favorites, and it uses Java.
GeeksForGeeks is a huge online community where you can find a lot of lectures and exercises for algorithms.

Unit testing

Every good programmer can test code, and not only their own, so learn how to write unit tests for your code. Sometimes newbies neglect unit testing preferring System.out.println validation type (if you already tried to write code, you know what I mean). Remember unit tests are much more useful than doing checks using console output. Unit tests are also the first thing companies typically trust new developers to write. According to the survey, 57.5% of respondents used JUnit before their first successful Java-related interview, and more than 83% had already used unit testing in their first job year.

Where to learn unit testing

Well, find a tutorial (for example this video tutorial or this text tutorial) and then create tests for all your code!

Utility Libraries and Useful Components

Some employers expect future programmers to know a number of tools and libraries that help in their work.

• Servlets are Java software components that extend the capabilities of a server.
• JDBC is a platform-independent standard for interaction between Java applications and databases. JDBC is implemented as a java.sql package included with Java SE (standard edition).
• log4j is the most famous library for logging messages. It allows you to write library calls in Java code and then flexibly customize it without changing the already written code.
• Jackson/JSON. JSON (JavaScript Object Notation) is an extremely popular open standard file format and data interchange format, while Jackson is a high-performance JSON processor for Java.

More than half of respondents have known these technologies before getting their first Java-related job. All newcomers have used JSON/Jackson at their job, and most of them used JDBC (84.8%) or log4j2 (83.3%). Two-thirds of respondents have used servlets during their first year as Java juniors and trainees.

• Guava is an open source set of common libraries for Java, mainly developed by Google engineers.
• Apache Commons is a huge Apache project focused on all aspects of reusable Java components.

While studying, I recommend that you devote time to log4j, JSON, JDBC (together with SQL and database tools). However, the other technologies from the list and the libraries can be useful too.

Where to learn utility libraries and useful components

• Text tutorial about log4j on tutorialspoint or video course on Udemy
• CodeGym has some JSON, log4j, JDBC topics, and exercises in their course.
• Java Servlets on edureca

Spring/Hibernate

Some time ago, no one demanded knowledge of frameworks from a junior, let alone a trainee. Times are changing, however, and some companies won’t get into it if you don’t have an understanding of these technologies. Learning to work with them on your own is very difficult, although possible. However, in this case, I would recommend finding courses and doing it with a mentor.

• Spring — 33.3% of respondents estimated their knowledge of Spring as “good or excellent” while 21.2% knew nothing about this framework.
• Spring Boot — 42.4% of respondents knew Spring Boot (good or excellent level), and 36.4% didn’t know it.
• Hibernate — 43.9% knew Hibernate on a good or excellent level, while 27.3% had never tried it.
• Java API for RESTful Web Services — 90.9% used it while working.

Where to learn Spring/Hibernate

As I said previously, the best way to learn Spring and Hibernate is to find courses with a small team and a tutor, but that’s not always possible. I have found some interesting resources for learning them.

Spring tutorial on Baeldung
Spring practical task
Spring tutorial and spring boot guide on spring.io
Hibernate and Spring on Udemy
RESTful API on Udemy

Design and Architectural Patterns and Principles of Programming

Design patterns are well-proven solutions for solving some specific problems. If you don’t know them, you give your future employer a headache. Take the time to read about patterns and apply them in practice. It’s the same story with architectural patterns, for example, MVC. I always ask my students to create some programs using MVC. It becomes much harder, but after that, they know how to use it.

Also, it would be beneficial to read about simple and well-readable code, according to KISS, DRY, and SOLID principles. To be honest, they are easy to understand, but it takes time to use them in practice. That’s why, when I interviewed applicants for junior positions, I never required applicants to have a solid knowledge of these principles, realizing that they come with practice.

Where to learn and read about patterns and principles

Refactoring guru
SOLID, KISS, DRY, YAGNI

Build Automation Tools, Application Servers, and Non-Java

There are technologies and skills that most IT pros should have in their arsenal. They are not directly related to Java, but I will still mention them — it is not difficult to study them at the initial level. Additionally, it is better to do this before you start work because at that point you will not have time for them.

Where to learn build automation tools, application servers, and non-Java

Gradle tutorials and Guides
Maven in 5 minutes
Introduction to Tomcat 7
JBoss
SQL, JavaScript, HTML, CSS on w3schools

Conclusions

Hmm … Looks a little scary, doesn’t it? On the other hand, if you love programming, are interested in technology, and are determined to become a programmer, then there’s no need to fear. Work step by step, practice, learn, and may the force be with you. The road will be mastered by the walking one.

First published on Better Programming.