Clean up your code.
As a Java developer, what do we do the most? That's right, code. What's less clear is that you're engaging in a craft that is guided by specific ideals. Fortunately, such ideas are teachable. There are several clean code blogs on the Internet, but I like excellent old books. A handful more suggestions are provided below.
Robert C. Martin's Clean Code (2008)
Joshua Bloch's Effective Java, 3rd Edition (2017)
One of the benefits of clean code that I value the most is its brevity. Aside from aesthetic considerations, there is an important economic rationale for this honour: Even though a sentence is only written once, it is likely to be read many times by numerous developers. A unnecessary line's waste accumulates over time and can add up to a significant expense. And, of course, more lines equals more bugs.
I built a routine that considerably aided my ability to write clean code. Pick 100 simple issues from leetcode, solve them on your own, then compare your answer to the best. You'll probably discover that the ideal solution just takes one or two lines, while yours requires a lot more. In that case, study the best answer, figure out why yours differs (or stinks), integrate your newfound knowledge, and pass the online judge 5 times for the identical problem. Gradually, your code will get more succinct. I'll keep my word.
No one is born with the ability to code brilliantly. Learn the fundamentals and put them into practise. Before you know it, you'll be there.
Mastering the language and JDK is a must.
I'm sure every Java developer has gone through some form of language instruction. However, you are losing out if you have not followed the official Java lessons. Except for the final two (deployment and Java certificate), I propose all of the fundamental tracks, as well as the following specialist paths:
Personalized Networking,
Generics,
JavaBeans,
Database Access using JDBC,
JMX,
JAXB,
contemplation, and Safety is paramount (a more interesting place for Java Security is actually here, which is referenced in this trail).
Also, have a look at JDK Tools and Utilities. Pay close attention to the Troubleshooting Tools section in particular! Those tools might save you a lot of grief in the future. Chapter 17 of the Java Language Specification, Threads and Locks, is also worth reading. It once assisted me in improving my grasp of concurrency in Java.
Grasp Gradle
Gradle is quickly becoming the go-to build tool for Java applications. It's possible that your team isn't utilising it right now, but I can practically promise that it will become your closest buddy as a Java developer.
For years, Gradle has been rapidly expanding. The size of the documents has also been a factor. I believe it has grown to the point where people, including myself, find the documentation page scary. The earlier versions, on the other hand, had a single page of table of contents for the Gradle User Guide (e.g., v2.5 documents), and the learning experience was fantastic for me. So, my advice is to have an old doc open on the side of the screen and follow the order there when navigating through the current version of the documentation.
After a few days of working on the user guide, you'll frequently need to refer to the Gradle DSL references. Because Project and Task are the two most commonly used kinds in a Gradle build script, I recommend reading through them to understand what's available.
Finally, I strongly advise you to go through the Plugin Development Tutorials. You may never need to develop one for your job, but odds are you'll need to study the source code of a company-owned plugin to debug some unexplained difficulties. Having prior knowledge with Gradle plugin development will come in handy in this case.
Administrate Jetty
Jetty's most important usefulness to me, aside from work, is that it helps me with my side projects. I've worked on a number of side projects, the most of them are web applications. Being able to administer Jetty makes it a lot easier for me. My preferred learning resource is the official Jetty doc.
Play with Hadoop
We are currently living in the Big Data age. As a result, Hadoop is nearly unavoidable for Java programmers. Vanilla map-reduce (MR) jobs written in Java are becoming increasingly rare. Knowing how to build an MR task in Java, on the other hand, is still useful because you may need to do it on occasion. More significantly, you may run across some challenges that demand a thorough grasp of how Hadoop works to resolve. Tom White's Hadoop: The Definitive Guide (2015) is a good resource for this.
Are you familiar with Java EE?
In the early days of my profession, I spent a lot of time looking over the official Java EE lesson. Based on my limited expertise, only a tiny number of technologies are highly relevant today. However, working through the course has provided me with an useful understanding of the use cases, typical concerns, and current state of the art in Java corporate apps.
Make use of Spring.
Whether you like it or not, the Spring framework is basically unavoidable if you undertake server-side Java programming in the long term. Because I learnt CDI first, I didn't like Spring at first because of some minor discrepancies (eg, I preferred CDI interception APIs to Spring AOP APIs). However, because it was so popular and I needed to utilise it for business, I progressively worked my way through the Spring framework documentation, reading most if not all of it. However, now that I've mastered it, I find it to be pretty user-friendly. As a result, I suggest it to you as well.
Recognize the Zookeeper
For most Java developers, learning Zookeeper is a difficult task. However, if you need to construct a distributed system, Zookeeper will be vital since it addresses the critical coordination problem for you. I can't convey how critical Zookeeper is for designing a distributed system in words, but once you do, you'll understand why.
Notes at the End
You've probably figured out a handful of things by now. To begin with, the list is significantly skewed toward Java engineers who work on the server side. This is due to the fact that I am one of them. Second, this isn't necessarily a checklist for becoming a great Java programmer. I wholeheartedly agree with you. More than what is stated is required to be a good Java developer. You'll see that you'll require a good troubleshooting capacity, which takes time to develop. Starting with excellent questions on Stack Overflow is what I propose. Even before I became a Java developer, I signed up. It turned out to be an excellent decision. I was able to solve a number of difficult situations just by asking the right questions. And I am confident that it will be beneficial to you as well.
Check out the Java course offered by A2N Academy.