10 Most Common Mistakes That Java Developers Make

If you’re working on any new programming language, there might be certain phases where you can get stuck. This eventually leads any developer to make minor-major errors and creates a roadblock towards their learning curve. Not to forget, as much as you’ll be making mistakes, you’ll achieve excellence. Besides this, learning Java is no different task and thus it can also be excelled with time and with the right resources (tutorials, courses, books, etc) but the path towards becoming an expert is not as simple as it sounds, you need to ensure that you’re avoiding all the “Basic” mistakes that most developers do when they’re at “Beginner” level.

No matter how better a programmer you are, it is always necessary to make some mistakes, and the best part is it’s good to be informed about the blunders that you’re doing and avoid making such errors while coding. That’s why we came up with this article to highlight the 10 most common mistakes that every developer makes during their coding life and it might give you some clarity on how to avoid those mistakes. So, let’s check them out one-by-one.

1. Lack of Knowledge in Open Source Libraries

Half knowledge can always be dangerous for anyone and that’s what developers at the rookie stage do. Having less knowledge of any library that they’re looking to integrate can lead to blunders. While working on Java, you will find a vast variety of libraries that can be incorporated within the line of codes. Over the years, since its first version was published, its dedicated team ensures to push and refresh all the clean and updated libraries and resources to their end developers for smooth work. Library for Unit testing such as Junit, or PrimeFaces for developing rich web applications. There are tons of other libraries with which you must be familiar to achieve excellence in Java Programming.

Note: If you wish to know more about Java Libraries, must read – Top 10 Libraries Every Java Developer Should Know

2. Understanding Code’s “Logic” is All You Need

It’s practically not possible and feasible to remember every line of code of any programming language. Let’s suppose you’ve memorized some syntaxes, and other elements of Java, but when it comes to implementing them on real-life projects, it will become much more problematic for you. Perhaps, when you’ll become fluent in programming, there can be stances that you might not need to take any reference (most likely because of over practice) but that’s a different scenario, so the more implementation you’ll start doing, the more complexity you’ll be able to handle on any real-life project.

Note: You can only become a successful programmer when you can build something from “Scratch”

3. Always Have an “Action Plan”

When you start working on any project, it is a must to have an action plan in order to execute your project. Even your stakeholders might ask you about the pattern of approaching the execution, be it design, task allocation, or finishing dedicated tasks on priority, all it requires is to have a clear course of action plan to be a successful java developer. Being a rookie, it is not much expected from you to work as planned but as we discussed above, everybody learns from their mistakes. As you’ll be moving upward in your expertise, you might start working on more complex designs and applications that can be challenging for you. That’s why it is recommended to set a pathway of your approachability towards tasks that can satisfy both (management and stakeholders).

4. ArrayList vs LinkedList

Since ArrayLists are more widely used and understood, doing so is simple. In many situations, LinkedLists outperform ArrayLists though, and vice versa. Considering the requirement, both perform remarkably well. In general, when an application requires storing and accessing data, ArrayLists are a better fit. When an application needs to manipulate the data that has been stored, LinkedLists are preferable.

5. Say No to “Memory Leakage”

As you’ll start working with Java programming language, you will learn that it offers a unique feature for managing memory automatically and that’s where the downfall of this feature relies. When we say automatic memory management, that doesn’t mean that you will avoid checking memory manually. That’s why, In order to survive any unavoidable memory leakage, developers should have the presence of mind to check on their project where they are writing the code to ensure that they are not leaving any stone unturned that leads to hampering performance degradation.

For reference, have a look at the example below that might cause a memory leakage: static field

private Random random = new Random();
public static final ArrayList<Double> list = new ArrayList<Double>(1000000);

@Test
public void checkMemoryLeak() throws InterruptedException {
    for (int k = 0; k < 1000000; k++) {
        list.add(random.nextDouble());
    }

    System.gc();

    // Allow GC do its Job
    Thread.sleep(10000);
}

*Note: Here, ArrayList is a static field that will never be created by JVM Garbage Collector.

If you want to learn Java and looking for some complete Java Courses then GeeksforGeeks is here to help you. Refer to the below-mentioned links:

• Java Programming Foundation – Self Paced
• Fundamentals of Java Collection Framework – Self Paced
• JAVA Backend Development – Live

6. Difference between =, ==, and .equals()

It is simple to confuse these three operators, especially the last two. Keep in mind that = is used as an assignment symbol. A referential equality comparison, or ==, determines if two objects point to the same location in memory. The equals() function determines whether the values of two objects are equal. Always compare objects, especially strings, using .equals().

String a = "Geeks";
String b = "for";
String c = "Geeks";

if ((a==c)) {
    if(a+b+c).equals("GeeksforGeeks) {
        System.out.println("GeeksforGeeks");
    }
} else {
    System.out.println("Not GeeksforGeeks");
}

7. Handling Null Values/Exceptions

The NullPointerException is a problem that the majority of Java developers have encountered. When a variable is declared but no object is assigned to it before attempting to use the contents of the variable, the NullPointerException is thrown. Making a catchphrase for NullPointerException rather than providing code to manage the underlying null pointer dereferences is a common error. When programs handle null pointer dereferences rather than catching or suppressing NullPointerExceptions, it can be very challenging to pinpoint which expression is responsible for the exception in the try block or is adding unnecessary performance impact. Although there are other approaches to dealing with null values, there are two that work well when dealing with a String argument.

Checking to see if the String Argument is Null:

boolean isNoun(String noun) {
    if (noun == null) {
        return false;
    }
  
    String nouns[] = noun.split(" ");
    if (nouns.length != 2) {
        return false;
    }
  
    return (isCapitalized(nouns[0]) && isCapitalized(nouns[1]));
}

Throw the NullPointerException on purpose rather than performing an explicit check:

boolean isNoun(String noun) Throws NullPointerException {
    if (noun == null) {
        return false;
    }
  
    String nouns[] = noun.split(" ");
    if (nouns.length != 2) {
        return false;
    }
  
    return (isCapitalized(nouns[0]) && isCapitalized(nouns[1]));
}

To explore other methods, refer to the following articles

• How to avoid NullPointerException in Java using Optional class?
• Fix “java.lang.NullPointerException” in Android Studio

8. Missing “Braces”

Leaving curly braces {} within the line of codes such as ( { and } ) can lead to a disastrous result. It often happens when a developer forgets to put an open brace and executes the code and developers at the rookie level make these mistakes so often during their initial period. However, IDEs and compilers can identify these small mistakes, but one must ensure to keep a close eye while opening any braces and close it immediately when moving on to the next section of code.

Now, look at the example below for a better understanding:

public void getFood(String type) {
    if (type.equals("Juice")) {
        System.out.print("Choose Juice");
    } else if (type.equals("Mango"))
        System.out.print("Choose Mango");
    }
}

However, the code seems fine – for some (except for the one brace that has been missed out while coding). The correction has been mentioned below:

public void getFood(String type) {
    if (type.equals("Juice")) {
        System.out.print("Choose Juice");
    } else if (type.equals("Mango")) { // missing brace added
        System.out.print("Choose Mango");
    }
}

9. Never Leave “Exceptions” Behind

The problem arises when a developer ignores writing code for Exception Handling. Besides this fact, there is no problem if the program has been executed without any pitfall. But, on the other hand, if the code fails silently, then it starts creating issues, and working on bugs is like taking 4 steps back before any advance movement. The best way to avoid it is by rethrowing it or mentioning comments in the logs, or maybe showing an error dialog to the user. These are possibly the best way to handle such scenarios but still, the best way would be if you’re avoiding the exception handling and also let other of your team members know why did this occur and what is your action plan for this.

10. Lack of Practice

One thing is for sure, there’s literally no use in reading and investing time if you are not practicing it on daily basis. It’s not going to help you anyway, working on real-life projects is different, and reading or watching any tutorials are different to fill this gap it is highly recommended to start getting hands-on experience and try to implement it as much as you can. Why writing code is much more efficient? It’s just because you must do errors, and create bugs and that can be possible only and only by practicing.

Summary

With the help of this article, we’ve tried to bring everything together in one place and offer a deep analysis by a list of the 10 Most Common Mistakes that Java Developers Make during their working tenure. It’s ok to make mistakes and that’s the part of learning only so better you this is a chance to enhance your capabilities and avoid making some of these mistakes and focus on enhancing your skills.

yuvraj10

Follow

Improve

Article Tags :

• GBlog
• Java

Practice Tags :

• Java