Code Optimization- JAVA ( Phần 1)

Trong bài đăng hôm nay, mình sẽ đề cập đến những phương pháp lập trình Java tốt nhất mà mình đã học được khi ở các dự án thực tế.

Use Efficient Data Structures and Algorithms:

Bad Code (Inefficient Algorithm):

Good Code (Using Binary Search):

Explanation: The bad code uses linear search, with a time complexity of O(n). The good code uses binary search, which has a time complexity of O(log n) for sorted arrays, making it more efficient.

NOTE: We can use “Collections.binarySearch(…)” instead of writing our code.

2. Minimize Object Instantiation:

Bad Code (Creating New Objects Unnecessarily):

Good Code (Reusing Objects):

Explanation: The bad code creates a new String object in each iteration, leading to unnecessary object instantiation and increased memory consumption. The good code reuses the same String object, reducing memory overhead.

3. Avoid String Concatenation in Loops:

Bad Code (String Concatenation in Loop):

Good Code (Using StringBuilder):

Explanation: String concatenation in a loop creates a new String object in each iteration, resulting in poor performance. The good code uses StringBuilder, which efficiently constructs strings without unnecessary object creations.

4. Optimize Looping Constructs:

Bad Code (Inefficient Looping):

Good Code (Using Enhanced for Loop):

Explanation: The bad code uses the traditional for loop with list.size() method in the loop condition, resulting in performance overhead due to method calls in each iteration. The good code uses an enhanced for loop, which is more concise and efficient.

5. Use Proper Exception Handling:

Bad Code (Catching Exception Broadly):

Good Code (Catching Specific Exceptions):

Explanation: Catching Exception broadly can hide unexpected errors and make debugging difficult. The good code catches specific exceptions, providing better error handling and allowing for more targeted exception-handling logic.

6. Prefer Immutable Objects:

Bad Code (Mutable Object):

Good Code (Immutable Object):

Explanation: Mutable objects can lead to unintended changes in state, making the code error-prone. Immutable objects, on the other hand, ensure thread safety and prevent unintended modifications, resulting in more reliable code.

7. Use Primitive Types Instead of Wrapper Classes:

Bad Code (Using Wrapper Classes):

Good Code (Using Primitive Types):

Explanation: Wrapper classes introduce additional memory overhead and boxing/unboxing operations. Using primitive types improves performance and reduces memory consumption.

8. Avoid Unnecessary Synchronization:

Bad Code (Synchronized Method):

Good Code (Unsynchronized Method):

Explanation: Excessive synchronization can lead to contention and performance degradation, especially in multi-threaded environments. Avoiding unnecessary synchronization improves scalability and performance.

9. Avoid Deep Object Hierarchies:

Bad Code (Deep Object Hierarchy):

Good Code (Shallow Object Hierarchy):

Explanation: Deep object hierarchies increase memory consumption and complexity, making the code harder to understand and maintain. Shallow object hierarchies simplify the code and improve performance.

NOTE: Better think of composition instead of inheritance.

10. Use Lazy Initialization:

Bad Code (Eager Initialization):

Good Code (Lazy Initialization):

Explanation: Eager initialization creates objects even if they may not be used, leading to unnecessary resource consumption. Lazy initialization defers object creation until it’s needed, improving performance and resource usage.